@skrr-ai/cli 0.1.21 → 0.1.23

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>>;
@@ -449,6 +450,8 @@ export declare function parseIntervalToMs(input: string): number;
 export type WatchFlagInputs = {
     watch?: string[];
     metricKey?: string[];
+    githubEvents?: string[];
+    githubRepository?: string;
     /** Already resolved to canonical space ids by the caller. */
     spaceIds?: string[];
     monitorIds?: string[];

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`),
@@ -438,11 +439,17 @@ function buildWatchedSources(inputs) {
     const metricKeys = (inputs.metricKey ?? []).filter(Boolean);
     const spaceIds = (inputs.spaceIds ?? []).filter(Boolean);
     const monitorIds = (inputs.monitorIds ?? []).filter(Boolean);
+    const githubEvents = (inputs.githubEvents ?? []).filter(Boolean);
+    const githubRepository = String(inputs.githubRepository || '')
+        .trim()
+        .toLowerCase();
     const effective = new Set(watched);
     if (spaceIds.length)
         effective.add('space');
     if (monitorIds.length)
         effective.add('monitor');
+    if (githubEvents.length)
+        effective.add('github');
     if (effective.has('space') && spaceIds.length === 0) {
         throw new Error('--watch space needs at least one --watch-space <space-id-or-ref>. ' +
             'The `space` source requires a scope id, which the enum on its own cannot carry.');
@@ -466,7 +473,7 @@ function buildWatchedSources(inputs) {
             seen.add(s);
         }
     }
-    for (const implied of ['space', 'monitor']) {
+    for (const implied of ['space', 'monitor', 'github']) {
         if (effective.has(implied) && !seen.has(implied)) {
             orderedSources.push(implied);
             seen.add(implied);
@@ -487,6 +494,30 @@ function buildWatchedSources(inputs) {
         else if (source === 'metrics' && metricKeys.length) {
             rows.push({ source, enabled: true, config: { metricKeys } });
         }
+        else if (source === 'github' && (githubEvents.length || githubRepository)) {
+            rows.push({
+                source,
+                enabled: true,
+                config: {
+                    ...(githubRepository ? { repository: githubRepository } : {}),
+                    ...(githubEvents.length
+                        ? {
+                            events: githubEvents.map((eventType) => ({
+                                entityType: 'github',
+                                eventType,
+                                ...(githubRepository
+                                    ? {
+                                        filterField: 'repoFullName',
+                                        filterMode: 'equals',
+                                        filterValue: githubRepository,
+                                    }
+                                    : {}),
+                            })),
+                        }
+                        : {}),
+                },
+            });
+        }
         else {
             rows.push({ source, enabled: true });
         }

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/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,54 @@ 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>;
     createdAt?: string;
-    expiresAt?: string;
+    updatedAt?: string;
 }
 /** `pause | resume | destroy | terminate | health-check` (MachineLeaseService). */
 export declare const HARNESS_LEASE_ACTIONS: string[];
@@ -80,6 +119,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 +188,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<{

package/dist/lib/harnesses.js

@@ -7,6 +7,7 @@ exports.getHarnessModels = getHarnessModels;
 exports.listHarnessProducts = listHarnessProducts;
 exports.getHarnessUsage = getHarnessUsage;
 exports.getAllHarnessUsage = getAllHarnessUsage;
+exports.getRuntimeMonthlySpend = getRuntimeMonthlySpend;
 exports.listQuotaAccounts = listQuotaAccounts;
 exports.getQuotaHistory = getQuotaHistory;
 exports.updateHarness = updateHarness;
@@ -71,6 +72,18 @@ async function getAllHarnessUsage() {
     const ownerWide = '?scope=all';
     return (0, api_fetch_1.apiFetch)('/api/harnesses/usage/aggregate' + ownerWide);
 }
+/**
+ * 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).
+ */
+async function getRuntimeMonthlySpend() {
+    return (0, api_fetch_1.apiFetch)('/api/harnesses/spend');
+}
 /** The CLI subscription accounts this user's daemons have reported readings for. */
 async function listQuotaAccounts() {
     return (0, api_fetch_1.apiFetch)('/api/harnesses/quota/accounts');
@@ -149,8 +162,23 @@ async function readHarnessPing(id, pingId) {
     return (0, api_fetch_1.apiFetch)(`/api/harnesses/${encodeURIComponent(id)}/ping/${encodeURIComponent(pingId)}`);
 }
 // ── Leases (hosted billing plane) ──────────────────────────────────────────
-async function listHarnessLeases() {
-    return (0, api_fetch_1.apiFetch)('/api/machines/leases');
+/**
+ * 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.
+ */
+async function listHarnessLeases(options = {}) {
+    const query = new URLSearchParams();
+    if (options.limit)
+        query.set('limit', String(options.limit));
+    if (options.state)
+        query.set('state', options.state);
+    if (options.machineProduct)
+        query.set('machineProduct', options.machineProduct);
+    const suffix = query.toString() ? `?${query.toString()}` : '';
+    return (0, api_fetch_1.apiFetch)(`/api/machines/leases${suffix}`);
 }
 async function getHarnessLease(leaseId) {
     return (0, api_fetch_1.apiFetch)(`/api/machines/leases/${encodeURIComponent(leaseId)}`);

package/dist/lib/hosted-machines.js

@@ -237,6 +237,15 @@ async function waitForHostedMachineReady(id, options) {
             const detail = hostedMachineErrorSummary(session);
             throw new Error(`Hosted Machine ${id} reached ${status}${detail ? `: ${detail}` : ''}`);
         }
+        // Async resume deliberately rolls a recoverable failure back to `paused`
+        // so the retained workspace remains resumable. That is terminal for THIS
+        // wait operation even though it is not terminal for the machine. The
+        // resuming transition clears old error state, so an error-bearing paused
+        // row here belongs to the attempt we just started.
+        if (status === 'paused') {
+            const detail = hostedMachineErrorSummary(session);
+            throw new Error(`Hosted Machine ${id} returned to paused before it became ready${detail ? `: ${detail}` : ''}`);
+        }
         if (options.timeoutMs && Date.now() - startedAt >= options.timeoutMs) {
             throw new HostedMachineReadyTimeoutError(id, hostedMachineProgressSummary(session));
         }

package/dist/lib/inbox.d.ts

@@ -4,7 +4,8 @@
  * Gap analysis §3.3 (b): *"50 个命令组中没有 `skrr inbox` / `listen` / `tail` /
  * `notify`，CLI 全是 pull"*. The audit's third use case wants an agent that
  * *"像真人一样时不时发两三条消息"* — and the reply half of that loop already
- * works (`skrr agents chat --conversation <id>` stamps `Message.intentId` and
+ * works (`skrr agents chat <agent-id> --conversation <id> --prompt "…"` stamps
+ * `Message.intentId` and
  * wakes the originating run). What was missing is the other direction: nothing
  * in the CLI ever told you the agent had said something.
  *

package/dist/lib/machines.d.ts

@@ -87,6 +87,23 @@ export interface Machine {
         canTerminate: boolean;
     };
 }
+/**
+ * What a machine's state actually is, when `offline` is doing two jobs.
+ *
+ * A TERMINATED ephemeral sandbox — destroyed, unrecoverable, `canResume:
+ * false`, no lease — rendered `offline`, identically to a machine that is
+ * merely not connected right now. Those are opposite situations: one can come
+ * back and one never will, and the board's original target turned out to be the
+ * second while every surface said the first. The only way to learn the
+ * difference was to run `skrr machines hosted list` separately and match
+ * sandbox ids by hand (OSK-7639).
+ *
+ * `canResume` is the discriminator the payload already carries: a machine that
+ * could come back says so, and a destroyed one cannot.
+ */
+export declare function machineStateLabel(machine: Machine): string;
+/** Is this a machine a user could still use, or bring back? */
+export declare function isReachableMachine(machine: Machine): boolean;
 /** The user-editable slice. Identities, capabilities and lifecycle are not. */
 export interface MachinePreferencesPatch {
     name?: string;

package/dist/lib/machines.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.machineStateLabel = machineStateLabel;
+exports.isReachableMachine = isReachableMachine;
 exports.liveHarnessCount = liveHarnessCount;
 exports.listMachines = listMachines;
 exports.getMachine = getMachine;
@@ -7,6 +9,33 @@ exports.updateMachine = updateMachine;
 exports.disconnectMachine = disconnectMachine;
 exports.resolveMachineRef = resolveMachineRef;
 const api_fetch_1 = require("./api-fetch");
+/**
+ * What a machine's state actually is, when `offline` is doing two jobs.
+ *
+ * A TERMINATED ephemeral sandbox — destroyed, unrecoverable, `canResume:
+ * false`, no lease — rendered `offline`, identically to a machine that is
+ * merely not connected right now. Those are opposite situations: one can come
+ * back and one never will, and the board's original target turned out to be the
+ * second while every surface said the first. The only way to learn the
+ * difference was to run `skrr machines hosted list` separately and match
+ * sandbox ids by hand (OSK-7639).
+ *
+ * `canResume` is the discriminator the payload already carries: a machine that
+ * could come back says so, and a destroyed one cannot.
+ */
+function machineStateLabel(machine) {
+    if (machine.status !== 'offline')
+        return machine.status;
+    const controls = machine.controls;
+    if (controls && controls.canResume === false && controls.canTerminate === false) {
+        return 'terminated';
+    }
+    return 'offline';
+}
+/** Is this a machine a user could still use, or bring back? */
+function isReachableMachine(machine) {
+    return machineStateLabel(machine) !== 'terminated' && machine.status !== 'offline';
+}
 /**
  * How many of a machine's harnesses still represent a capability it has.
  *