@skrr-ai/cli 0.1.22 → 0.1.24

package/dist/lib/balance.d.ts

@@ -163,6 +163,14 @@ export interface BalanceStatementEntry {
     service: string | null;
     provider: string | null;
     model: string | null;
+    /**
+     * WHICH agent and conversation incurred it (OSK-7641).
+     *
+     * Optional because they are: the ledger carries them only where the producer
+     * knows them, and an older row has neither.
+     */
+    agentId?: string | null;
+    conversationId?: string | null;
     /** What incurred it, e.g. `session` / `run` — with `sourceId`, the thing
      * `balance history` could never name. */
     sourceType?: string;

package/dist/lib/commitment-product.d.ts

@@ -1,4 +1,4 @@
-import type { CommitmentDeliveryIntent, CommitmentExecutionReceipt } from '@skrr-ai/data-provider';
+import type { CommitmentDeliveryIntent, CommitmentExecutionReceipt, CommitmentExecutionReceiptQuarterlyMetricsResponse } from '@skrr-ai/data-provider';
 export declare const COMMITMENT_PRODUCT_MODES: readonly ["monitor", "prepare", "execute"];
 export declare const COMMITMENT_DELIVERY_CHOICES: readonly ["report-only", "local-patch", "draft-pr", "push-branch", "direct-branch"];
 /** Compatibility is accepted at the input boundary; everyday output uses the product contract. */
@@ -12,3 +12,12 @@ export declare function deliveryInput(mode: string, options?: {
 /** Monitor is observation-only; retain report expectations, never repo coordinates. */
 export declare function deliveryForProductMode(mode: string | undefined, delivery?: CommitmentDeliveryIntent): CommitmentDeliveryIntent | undefined;
 export declare function renderExecutionReceipt(receipt: CommitmentExecutionReceipt, log: (line: string) => void, verbose?: boolean): void;
+/**
+ * `skrr commitments receipt-metrics <id>` — the closed-quarter rollup.
+ *
+ * Ordered as the funnel it describes rather than as the payload's field order:
+ * a wake arrives, some wakes were eligible to act on, some of those started an
+ * execution, some declared a delivery, and some of THOSE were verified. Reading
+ * it top to bottom is how you see which step the loop is losing work at.
+ */
+export declare function renderExecutionReceiptQuarterlyMetrics(response: CommitmentExecutionReceiptQuarterlyMetricsResponse, log: (line: string) => void, verbose?: boolean): void;

package/dist/lib/commitment-product.js

@@ -7,6 +7,7 @@ exports.deliveryLabel = deliveryLabel;
 exports.deliveryInput = deliveryInput;
 exports.deliveryForProductMode = deliveryForProductMode;
 exports.renderExecutionReceipt = renderExecutionReceipt;
+exports.renderExecutionReceiptQuarterlyMetrics = renderExecutionReceiptQuarterlyMetrics;
 exports.COMMITMENT_PRODUCT_MODES = ['monitor', 'prepare', 'execute'];
 exports.COMMITMENT_DELIVERY_CHOICES = [
     'report-only',
@@ -71,8 +72,9 @@ function renderExecutionReceipt(receipt, log, verbose = false) {
         const mark = { done: '✓', working: '→', waiting: '…', failed: '×', skipped: '–' }[phase.status];
         log(`  ${mark} ${phase.phase[0].toUpperCase() + phase.phase.slice(1)}: ${phase.summary}${phase.at ? ` · ${phase.at}` : ''}`);
         for (const evidence of phase.evidence) {
-            if (evidence.url)
-                log(`    ${evidence.label}: ${evidence.url}`);
+            const location = evidence.url || evidence.path;
+            if (location)
+                log(`    ${evidence.label}: ${location}`);
         }
     }
     if (receipt.nextActor)
@@ -85,3 +87,65 @@ function renderExecutionReceipt(receipt, log, verbose = false) {
     if (verbose)
         log(`Diagnostics:\n${JSON.stringify({ id: receipt.id, revision: receipt.revision, evidence: receipt.evidence, diagnostics: receipt.diagnostics }, null, 2)}`);
 }
+/**
+ * A rate the server could not compute is NOT zero.
+ *
+ * Every `*Rate` on the metrics payload is `number | null`, and the null means
+ * "no denominator in this cohort" — a quarter with no eligible material wake
+ * has no verified-outcome rate to report. Printing that as `0%` would read as
+ * "we tried and delivered nothing", which is the opposite of "we were never
+ * asked". So an absent rate renders as an em dash and stays visibly absent.
+ */
+function rate(value) {
+    if (value === null || value === undefined)
+        return '—';
+    return `${(value * 100).toFixed(1)}%`;
+}
+/** Same rule for a ratio that is not a percentage. */
+function ratio(value) {
+    if (value === null || value === undefined)
+        return '—';
+    return value.toFixed(2);
+}
+/**
+ * `skrr commitments receipt-metrics <id>` — the closed-quarter rollup.
+ *
+ * Ordered as the funnel it describes rather than as the payload's field order:
+ * a wake arrives, some wakes were eligible to act on, some of those started an
+ * execution, some declared a delivery, and some of THOSE were verified. Reading
+ * it top to bottom is how you see which step the loop is losing work at.
+ */
+function renderExecutionReceiptQuarterlyMetrics(response, log, verbose = false) {
+    const { cohort, metrics } = response;
+    log(`Q${cohort.quarter} ${cohort.year} · ${cohort.from} → ${cohort.to}`);
+    log(`Checks in cohort: ${cohort.checkCount} · receipts: ${metrics.receiptCount}`);
+    log('');
+    log('Funnel');
+    log(`  Material wakes:        ${metrics.materialWakes} (${metrics.eligibleMaterialWakes} eligible)`);
+    log(`  Execute starts:        ${metrics.executeStarts}`);
+    log(`  Declared deliveries:   ${metrics.declaredDeliveries}`);
+    log(`  Verified outcomes:     ${metrics.verifiedOutcomes}`);
+    log(`  Blocked:               ${metrics.blocked}`);
+    log('');
+    log('Rates');
+    log(`  Verified per eligible wake:   ${ratio(metrics.verifiedOutcomesPerEligibleMaterialWake)}`);
+    log(`  Verified outcome rate:        ${rate(metrics.verifiedOutcomeRate)}`);
+    log(`  Delivery ratio:               ${rate(metrics.deliveryRatio)}`);
+    log(`  Autonomous, no intervention:  ${rate(metrics.autonomousDeliveryWithoutInterventionRate)}`);
+    log(`  Human intervention rate:      ${rate(metrics.humanInterventionRate)}`);
+    log(`  Orphaned delivery rate:       ${rate(metrics.orphanedDeliveryRate)}`);
+    log(`  False ready / false blocked:  ${rate(metrics.falseReadyRate)} / ${rate(metrics.falseBlockedRate)}`);
+    // The unknown counts decide whether the rates above are worth acting on, so
+    // they are one flag away rather than buried in --json.
+    if (verbose) {
+        const m = metrics.measurement;
+        log('');
+        log('Measurement');
+        log(`  Cohort:                 ${m.cohort}`);
+        log(`  Intervention:           ${m.interventionDefinition}`);
+        log(`  Eligible material wake: ${m.eligibleMaterialWakeDefinition}`);
+        log(`  Unknown admission runs: ${m.unknownAdmissionRuns} · unknown startup runs: ${m.unknownStartupRuns}`);
+        log(`  Tracked completed runs: ${m.trackedCompletedRuns}`);
+        log(`  Time to explanation:    p50 ${metrics.timeToExplanationMs.p50 ?? '—'}ms · p95 ${metrics.timeToExplanationMs.p95 ?? '—'}ms (n=${metrics.timeToExplanationMs.count})`);
+    }
+}

package/dist/lib/commitments.d.ts

@@ -17,7 +17,7 @@
  * "hold this state", derived from a Compass invariant — not authored here).
  */
 import { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, COMMITMENT_AUTONOMY_MODES, COMMITMENT_EXECUTION_ISOLATION_MODES } from '@skrr-ai/data-provider';
-import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, CommitmentExecutionReceiptListResponse, CommitmentCapabilitySource, CommitmentDeliveryPatchResponse, CommitmentDeliveryBundleResponse } from '@skrr-ai/data-provider';
+import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, CommitmentExecutionReceiptListResponse, CommitmentExecutionReceiptQuarterlyMetricsResponse, CommitmentCapabilitySource, CommitmentDeliveryPatchResponse, CommitmentDeliveryBundleResponse } from '@skrr-ai/data-provider';
 import { withQuery } from './triggers';
 export { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, };
 export type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, };
@@ -284,6 +284,7 @@ export declare const commitmentApi: {
     mode: (id: string, body: Record<string, unknown>) => Promise<Commitment>;
     delivery: (id: string, body: Record<string, unknown>) => Promise<Commitment>;
     receipts: (id: string, limit?: number) => Promise<CommitmentExecutionReceiptListResponse>;
+    receiptQuarterlyMetrics: (id: string, year: number, quarter: number) => Promise<CommitmentExecutionReceiptQuarterlyMetricsResponse>;
     deliveryPatch: (id: string, taskId: string) => Promise<CommitmentDeliveryPatchResponse>;
     deliveryBundle: (id: string, taskId: string) => Promise<CommitmentDeliveryBundleResponse>;
     operatingReview: (agentId: string) => Promise<Record<string, unknown>>;

package/dist/lib/commitments.js

@@ -183,6 +183,7 @@ exports.commitmentApi = {
     mode: (id, body) => data_provider_1.request.post(`${base(id)}/mode`, body),
     delivery: (id, body) => data_provider_1.request.post(`${base(id)}/delivery`, body),
     receipts: (id, limit = 1) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/receipts`, { limit })),
+    receiptQuarterlyMetrics: (id, year, quarter) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/receipt-metrics/quarterly`, { year, quarter })),
     deliveryPatch: (id, taskId) => data_provider_1.request.get(`${base(id)}/delivery/${encodeURIComponent(taskId)}/patch`),
     deliveryBundle: (id, taskId) => data_provider_1.request.get(`${base(id)}/delivery/${encodeURIComponent(taskId)}/bundle`),
     operatingReview: (agentId) => data_provider_1.request.get(`/api/commitments/agents/${encodeURIComponent(agentId)}/operating-review`),

package/dist/lib/conversation-search.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizedSnippetLength(value: number): number;
+/** Keep search output a navigation result, never a transcript payload. */
+export declare function compactMessageSearchHit(message: Record<string, unknown>, requestedSnippetLength: number, query?: string): Record<string, unknown>;

package/dist/lib/conversation-search.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizedSnippetLength = normalizedSnippetLength;
+exports.compactMessageSearchHit = compactMessageSearchHit;
+const MAX_SEARCH_SNIPPET_CHARS = 4000;
+function normalizedSnippetLength(value) {
+    if (!Number.isFinite(value))
+        return 160;
+    return Math.min(MAX_SEARCH_SNIPPET_CHARS, Math.max(1, Math.trunc(value)));
+}
+function findQueryMatch(text, query) {
+    const normalizedQuery = query.trim().toLocaleLowerCase();
+    if (!normalizedQuery)
+        return null;
+    const loweredText = text.toLocaleLowerCase();
+    const exactAt = loweredText.indexOf(normalizedQuery);
+    if (exactAt >= 0)
+        return { at: exactAt, length: normalizedQuery.length };
+    // Meilisearch tokenizes punctuation-bearing queries and can legitimately
+    // match AGENT_EMPTY_RESPONSE as separate words. If the exact phrase is not
+    // present, center on the earliest substantive query token so the bounded CLI
+    // result still explains why it matched instead of truncating just before the
+    // highlighted word returned by the server crop.
+    const tokens = Array.from(new Set(normalizedQuery.split(/[^\p{L}\p{N}]+/u).filter((token) => token.length >= 2)));
+    let best = null;
+    for (const token of tokens) {
+        const at = loweredText.indexOf(token);
+        if (at >= 0 && (!best || at < best.at))
+            best = { at, length: token.length };
+    }
+    return best;
+}
+/** Keep search output a navigation result, never a transcript payload. */
+function compactMessageSearchHit(message, requestedSnippetLength, query = '') {
+    const limit = normalizedSnippetLength(requestedSnippetLength);
+    const normalizedText = String(message.text ?? '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const normalizedQuery = query.trim();
+    let text = normalizedText;
+    if (!text) {
+        text = '[matching text unavailable]';
+    }
+    else if (text.length > limit) {
+        const match = findQueryMatch(text, normalizedQuery);
+        if (!match) {
+            text = text.slice(0, limit);
+        }
+        else {
+            const matchAt = match.at;
+            const matchLength = Math.min(match.length, limit);
+            const prefixBudget = Math.floor((limit - matchLength) / 2);
+            let start = Math.max(0, matchAt - prefixBudget);
+            let prefix = start > 0 ? '…' : '';
+            let suffix = '…';
+            let contentBudget = Math.max(1, limit - prefix.length - suffix.length);
+            start = Math.min(start, Math.max(0, text.length - contentBudget));
+            prefix = start > 0 ? '…' : '';
+            suffix = start + contentBudget < text.length ? '…' : '';
+            contentBudget = Math.max(1, limit - prefix.length - suffix.length);
+            start = Math.min(start, Math.max(0, text.length - contentBudget));
+            text = `${prefix}${text.slice(start, start + contentBudget)}${suffix}`;
+        }
+    }
+    text = text.slice(0, limit);
+    return {
+        messageId: message.messageId,
+        conversationId: message.conversationId,
+        title: message.title,
+        sender: message.sender,
+        isCreatedByUser: message.isCreatedByUser,
+        createdAt: message.createdAt,
+        text,
+    };
+}

package/dist/lib/dedicated-machines.d.ts

@@ -0,0 +1,66 @@
+import { type HarnessLease } from './harnesses';
+export type DedicatedLeaseAction = 'start' | 'stop' | 'restart' | 'snapshot' | 'health-check';
+export declare const DEDICATED_LEASE_ACTIONS: DedicatedLeaseAction[];
+export interface DedicatedRuntimeScope {
+    workspaceId?: string;
+}
+export interface CreateDedicatedRuntimeInput extends DedicatedRuntimeScope {
+    requestId: string;
+    displayName: string;
+    sizePreset: string;
+    regionClass?: string;
+    storageGb?: number;
+    retentionClass?: string;
+    backupProfile?: 'crash-consistent' | 'application-consistent';
+    monthlySpendingLimitCents: number;
+    repositoryRef?: string;
+}
+export interface DedicatedRuntimeResponse {
+    lease?: HarnessLease;
+}
+/**
+ * Flags in, request body out — and the point of it being a function is the
+ * OMISSION.
+ *
+ * A field the user did not set must be ABSENT from the body, not present as
+ * `undefined`, because the server reaches its own default through
+ * `input.x || <default>`. Restating those defaults on the client looks
+ * harmless and is not: `--storage-gb` shipped with a client default of 100
+ * against a product default of 50, so a user who never chose a disk size was
+ * billed for twice the documented one and `workspaceDefaultGb` was unreachable
+ * through the CLI. The three neighbouring flags happened to agree, which only
+ * means the same bug was invisible in them.
+ */
+export declare function dedicatedRuntimeCreateInput(input: {
+    requestId: string;
+    displayName: string;
+    sizePreset: string;
+    monthlySpendingLimitCents: number;
+    regionClass?: string;
+    storageGb?: number;
+    retentionClass?: string;
+    backupProfile?: string;
+    workspaceId?: string;
+}): CreateDedicatedRuntimeInput;
+export declare function createDedicatedRuntime(input: CreateDedicatedRuntimeInput): Promise<DedicatedRuntimeResponse>;
+export declare function listDedicatedRuntimes(options?: {
+    limit?: number;
+    state?: string;
+}): Promise<{
+    leases?: HarnessLease[];
+}>;
+export declare function getDedicatedRuntime(leaseId: string): Promise<DedicatedRuntimeResponse>;
+export declare function performDedicatedLeaseAction(leaseId: string, action: DedicatedLeaseAction): Promise<DedicatedRuntimeResponse>;
+export declare function growDedicatedRuntime(leaseId: string, storageGb: number, options?: {
+    requestId?: string;
+}): Promise<DedicatedRuntimeResponse>;
+export declare function closeDedicatedRuntimeIncidentHold(leaseId: string, options?: {
+    requestId?: string;
+}): Promise<DedicatedRuntimeResponse>;
+export declare function destroyDedicatedRuntime(leaseId: string, options?: {
+    retentionIntent?: 'retain' | 'purge';
+}): Promise<DedicatedRuntimeResponse>;
+export declare function dedicatedLeaseId(lease: HarnessLease | undefined | null): string;
+export declare function dedicatedLeaseState(lease: HarnessLease | undefined | null): string;
+export declare function dedicatedLeaseDisplayName(lease: HarnessLease | undefined | null): string;
+export declare function formatDedicatedRuntimeApiError(err: unknown): string | null;

package/dist/lib/dedicated-machines.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEDICATED_LEASE_ACTIONS = void 0;
+exports.dedicatedRuntimeCreateInput = dedicatedRuntimeCreateInput;
+exports.createDedicatedRuntime = createDedicatedRuntime;
+exports.listDedicatedRuntimes = listDedicatedRuntimes;
+exports.getDedicatedRuntime = getDedicatedRuntime;
+exports.performDedicatedLeaseAction = performDedicatedLeaseAction;
+exports.growDedicatedRuntime = growDedicatedRuntime;
+exports.closeDedicatedRuntimeIncidentHold = closeDedicatedRuntimeIncidentHold;
+exports.destroyDedicatedRuntime = destroyDedicatedRuntime;
+exports.dedicatedLeaseId = dedicatedLeaseId;
+exports.dedicatedLeaseState = dedicatedLeaseState;
+exports.dedicatedLeaseDisplayName = dedicatedLeaseDisplayName;
+exports.formatDedicatedRuntimeApiError = formatDedicatedRuntimeApiError;
+const api_fetch_1 = require("./api-fetch");
+const harnesses_1 = require("./harnesses");
+exports.DEDICATED_LEASE_ACTIONS = [
+    'start',
+    'stop',
+    'restart',
+    'snapshot',
+    'health-check',
+];
+/**
+ * Flags in, request body out — and the point of it being a function is the
+ * OMISSION.
+ *
+ * A field the user did not set must be ABSENT from the body, not present as
+ * `undefined`, because the server reaches its own default through
+ * `input.x || <default>`. Restating those defaults on the client looks
+ * harmless and is not: `--storage-gb` shipped with a client default of 100
+ * against a product default of 50, so a user who never chose a disk size was
+ * billed for twice the documented one and `workspaceDefaultGb` was unreachable
+ * through the CLI. The three neighbouring flags happened to agree, which only
+ * means the same bug was invisible in them.
+ */
+function dedicatedRuntimeCreateInput(input) {
+    return {
+        requestId: input.requestId,
+        displayName: input.displayName,
+        sizePreset: input.sizePreset,
+        monthlySpendingLimitCents: input.monthlySpendingLimitCents,
+        ...(input.regionClass ? { regionClass: input.regionClass } : {}),
+        ...(input.storageGb !== undefined ? { storageGb: input.storageGb } : {}),
+        ...(input.retentionClass ? { retentionClass: input.retentionClass } : {}),
+        ...(input.backupProfile
+            ? { backupProfile: input.backupProfile }
+            : {}),
+        ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
+    };
+}
+async function createDedicatedRuntime(input) {
+    const { requestId, workspaceId, ...body } = input;
+    if (workspaceId) {
+        return (0, api_fetch_1.apiFetch)(`/api/machines/dedicated?workspaceId=${encodeURIComponent(workspaceId)}`, {
+            method: 'POST',
+            body,
+            headers: { 'Idempotency-Key': requestId },
+        });
+    }
+    return (0, api_fetch_1.apiFetch)('/api/machines/dedicated', {
+        method: 'POST',
+        body,
+        headers: { 'Idempotency-Key': requestId },
+    });
+}
+async function listDedicatedRuntimes(options = {}) {
+    return (0, harnesses_1.listHarnessLeases)({
+        ...options,
+        machineProduct: 'dedicated-machine',
+    });
+}
+async function getDedicatedRuntime(leaseId) {
+    return (0, harnesses_1.getHarnessLease)(leaseId);
+}
+async function performDedicatedLeaseAction(leaseId, action) {
+    return (0, harnesses_1.performHarnessLeaseAction)(leaseId, action);
+}
+async function growDedicatedRuntime(leaseId, storageGb, options = {}) {
+    return (0, api_fetch_1.apiFetch)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/storage`, {
+        method: 'POST',
+        body: { storageGb },
+        ...(options.requestId ? { headers: { 'Idempotency-Key': options.requestId } } : {}),
+    });
+}
+async function closeDedicatedRuntimeIncidentHold(leaseId, options = {}) {
+    return (0, api_fetch_1.apiFetch)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/incident-hold/close`, {
+        method: 'POST',
+        body: {},
+        ...(options.requestId ? { headers: { 'Idempotency-Key': options.requestId } } : {}),
+    });
+}
+async function destroyDedicatedRuntime(leaseId, options = {}) {
+    const query = options.retentionIntent
+        ? `?retentionIntent=${encodeURIComponent(options.retentionIntent)}`
+        : '';
+    return (0, api_fetch_1.apiFetch)(`/api/machines/leases/${encodeURIComponent(leaseId)}${query}`, { method: 'DELETE' });
+}
+function dedicatedLeaseId(lease) {
+    return String(lease?.id ?? '');
+}
+function dedicatedLeaseState(lease) {
+    return String(lease?.state ?? 'unknown');
+}
+function dedicatedLeaseDisplayName(lease) {
+    return lease?.displayName ? String(lease.displayName) : '-';
+}
+/**
+ * Dedicated Runtime commands are unusually likely to meet a server that has
+ * never heard of them.
+ *
+ * The CLI ships independently of the API (`@skrr-ai/cli` on npm), so "CLI newer
+ * than the deployed server" is the normal state for anyone who runs
+ * `npm update`, and this feature widened that window: twelve commands arrived at
+ * once, and three of them call endpoints that land in a later deploy. The server
+ * redacts an unknown-route 404 to "An unexpected error occurred.", so every one
+ * of those users got eight words that cannot be told apart from a wrong lease
+ * id or a broken server.
+ *
+ * A 404 carrying no product `code` is that case. Naming it is the difference
+ * between "wait for the deploy" and "open a bug".
+ */
+function describeMissingEndpoint(err) {
+    if (err.status !== 404) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(err.body || '');
+        // A product code means the server DID handle the route and refused on the
+        // merits — that message is the useful one and must not be overwritten.
+        if (parsed.code) {
+            return null;
+        }
+    }
+    catch {
+        // Unparseable body: no product code by definition.
+    }
+    return ('This server does not have that Dedicated Runtime endpoint. Your CLI is probably ahead of ' +
+        'the deployment — `skrr context` names the server it is talking to, and `skrr machines ' +
+        'dedicated list` will still work if the feature is deployed at all.');
+}
+function formatDedicatedRuntimeApiError(err) {
+    if (!(err instanceof api_fetch_1.ApiFetchError) || !err.body) {
+        return null;
+    }
+    if (err.status === 401) {
+        return null;
+    }
+    const missingEndpoint = describeMissingEndpoint(err);
+    if (missingEndpoint) {
+        return missingEndpoint;
+    }
+    try {
+        const parsed = JSON.parse(err.body);
+        return parsed.message || parsed.error || parsed.code || null;
+    }
+    catch {
+        return err.body.trim() || null;
+    }
+}

package/dist/lib/execution-target.d.ts

@@ -21,8 +21,29 @@ export interface BuildExecutionOrderPatchInput {
     selectors: string[];
     /** Reasons that permit each non-final target to advance. */
     advanceOn?: string[];
+    /**
+     * No category permits an advance — a STRICT chain.
+     *
+     * `advanceOn` omitted defaults to `['offline','unavailable']` on every
+     * non-final target (see below), and the enum has no empty member, so
+     * "strictly pinned, with a declared next target" was inexpressible from any
+     * flag: the only way to build it was to bypass the flags entirely and
+     * hand-write `executionPolicy` through `--from-json` (OSK-7669).
+     */
+    strict?: boolean;
 }
 export declare function normalizeExecutionTargetSelector(input: string): string;
 export declare function normalizeAdvanceReasons(values: string[] | undefined): ExecutionTargetAdvanceReason[];
 export declare function executionTargetForSelector(input: string): AgentExecutionTarget;
+/**
+ * What a non-final target may advance on when the caller said nothing.
+ *
+ * Exported because it is a DEFAULT the operator is not told about anywhere:
+ * `--advance-on` reads as an explicit opt-in ("Failure category that PERMITS
+ * the current target to advance"), so omitting it looks like opting into
+ * nothing — and it grants two categories on a target the caller explicitly
+ * pinned (OSK-7669). Naming it here lets the help text and the confirmation
+ * output say the same thing the code does.
+ */
+export declare const DEFAULT_ADVANCE_REASONS: readonly ExecutionTargetAdvanceReason[];
 export declare function buildExecutionOrderPatch(input: BuildExecutionOrderPatchInput): AgentExecutionPatch;

package/dist/lib/execution-target.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXECUTION_TARGET_ADVANCE_REASONS = void 0;
+exports.DEFAULT_ADVANCE_REASONS = exports.EXECUTION_TARGET_ADVANCE_REASONS = void 0;
 exports.normalizeExecutionTargetSelector = normalizeExecutionTargetSelector;
 exports.normalizeAdvanceReasons = normalizeAdvanceReasons;
 exports.executionTargetForSelector = executionTargetForSelector;
@@ -78,6 +78,20 @@ function executionTargetForSelector(input) {
         managedUsageConsent: false,
     };
 }
+/**
+ * What a non-final target may advance on when the caller said nothing.
+ *
+ * Exported because it is a DEFAULT the operator is not told about anywhere:
+ * `--advance-on` reads as an explicit opt-in ("Failure category that PERMITS
+ * the current target to advance"), so omitting it looks like opting into
+ * nothing — and it grants two categories on a target the caller explicitly
+ * pinned (OSK-7669). Naming it here lets the help text and the confirmation
+ * output say the same thing the code does.
+ */
+exports.DEFAULT_ADVANCE_REASONS = [
+    'offline',
+    'unavailable',
+];
 function buildExecutionOrderPatch(input) {
     const values = input.selectors.map((value) => String(value || '').trim()).filter(Boolean);
     if (values.length === 0)
@@ -91,11 +105,13 @@ function buildExecutionOrderPatch(input) {
             mode: 'ordered',
             targets: targets.map((target, index) => ({
                 ...target,
-                advanceOn: index < targets.length - 1
-                    ? advanceOn.length > 0
-                        ? advanceOn
-                        : ['offline', 'unavailable']
-                    : [],
+                advanceOn: input.strict
+                    ? []
+                    : index < targets.length - 1
+                        ? advanceOn.length > 0
+                            ? advanceOn
+                            : [...exports.DEFAULT_ADVANCE_REASONS]
+                        : [],
             })),
         },
     };

package/dist/lib/harnesses.d.ts

@@ -51,15 +51,59 @@ export interface Harness {
     claudeEngine?: 'cli' | 'sdk';
     lastSeenAt?: string;
 }
+/**
+ * One open lease, as `/api/machines/leases` actually returns it.
+ *
+ * This shape was previously guessed — it declared `productId`, `runtimeId` and
+ * `expiresAt`, none of which the server has ever sent. Optional properties made
+ * that compile, so `leases list` rendered three permanently empty columns while
+ * `--json` showed the data plainly, and the one view built to tell a
+ * Hosted Machine lease from a Hosted Job Machine lease could not.
+ *
+ * So: only fields `toPublicMachineLeasePayload` emits belong here. There is no
+ * expiry on a lease — it lives until released — and no top-level runtime id.
+ */
 export interface HarnessLease {
     id?: string;
-    leaseId?: string;
-    productId?: string;
+    machineProduct?: string;
+    machineProductLabel?: string;
+    displayName?: string;
     state?: string;
-    runtimeId?: string;
-    workspaceId?: string | null;
+    stateReason?: string;
+    lifecycleSemantics?: string;
+    /**
+     * `active | paused | storage | none` — whether this lease is still costing
+     * money — plus the monthly spend status the server already computes.
+     *
+     * These six were allow-listed in `PUBLIC_RUNTIME_BILLING_KEYS` and attached
+     * by `attachMonthlySpendStatus` on every lease read, and the web renders
+     * them. Nothing in the CLI read them, so the number that actually refuses a
+     * Hosted Machine — the MONTHLY cap — was unreadable from here while
+     * `skrr balance show` reported a DAILY cap with full headroom. A user who
+     * correctly suspected billing could not confirm it (OSK-7920).
+     */
+    billing?: {
+        billableState?: string;
+        monthlySpendLimitCents?: number | null;
+        currentMonthSpendCents?: number;
+        openUsageEstimateCents?: number;
+        projectedCurrentMonthSpendCents?: number;
+        spendingLimitExceeded?: boolean;
+        spendStatusUnavailable?: boolean;
+        monthStartedAt?: string | null;
+    } & Record<string, unknown>;
+    leaseTimestamps?: Record<string, string>;
+    health?: {
+        assignable?: boolean;
+        reasons?: string[];
+    } & Record<string, unknown>;
+    storage?: {
+        retentionClass?: string;
+        lastBackupAt?: string;
+        backupProfile?: string;
+    };
     createdAt?: string;
-    expiresAt?: string;
+    updatedAt?: string;
 }
 /** `pause | resume | destroy | terminate | health-check` (MachineLeaseService). */
 export declare const HARNESS_LEASE_ACTIONS: string[];
@@ -80,6 +124,32 @@ export declare function getHarnessUsage(id: string): Promise<unknown>;
 /** The rollup across every harness. The web calls this key `fleetUsage`. */
 export declare function getAllHarnessUsage(): Promise<unknown>;
 export type { QuotaAccountSummary, QuotaHistory };
+/** One hosted product's monthly runtime spend cap and where this month stands. */
+export type RuntimeMonthlySpend = {
+    machineProduct: string;
+    hasLimit: boolean;
+    exceeded?: boolean;
+    limitCents?: number;
+    currentSpendCents?: number;
+    openUsageEstimateCents?: number;
+    projectedCents?: number;
+    monthStartedAt?: string;
+};
+/**
+ * The monthly runtime spend cap, read before it refuses anything.
+ *
+ * Distinct from the balance's own spend cap, which is a per-period RATE LIMIT
+ * on credits. A user can have headroom on that one and still be refused by
+ * this one, which is exactly what happened: every number on `balance show`
+ * said there was room while a monthly hosted-runtime cap turned every turn
+ * away (OSK-7920).
+ */
+export declare function getRuntimeMonthlySpend(): Promise<{
+    scope: {
+        teamId: string | null;
+    };
+    spend: RuntimeMonthlySpend[];
+}>;
 /** The CLI subscription accounts this user's daemons have reported readings for. */
 export declare function listQuotaAccounts(): Promise<{
     accounts: QuotaAccountSummary[];
@@ -123,7 +193,18 @@ export declare function readHarnessPing(id: string, pingId: string): Promise<{
     latencyMs?: number;
     error?: string;
 }>;
-export declare function listHarnessLeases(): Promise<{
+/**
+ * List leases. The server answers newest-first and caps at 50 unless asked
+ * otherwise (`Math.min(Math.max(Number(limit) || 50, 1), 100)`), so an account
+ * with more than fifty leases could not see past the newest fifty from here —
+ * including `lost` ones, which are terminal, invisible, and still billed for
+ * the whole window the platform had lost track of them.
+ */
+export declare function listHarnessLeases(options?: {
+    limit?: number;
+    state?: string;
+    machineProduct?: string;
+}): Promise<{
     leases?: HarnessLease[];
 }>;
 export declare function getHarnessLease(leaseId: string): Promise<{