@skrr-ai/cli 0.1.91 → 0.1.93

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

@@ -0,0 +1,69 @@
+import { type Attribution, type DistributionChannel, type ResolveAgentVanityResponse, type ResolveDistributionCodeResponse } from '@skrr-ai/data-provider';
+/**
+ * THE ONE PLACE A STORE AGENT REFERENCE IS RESOLVED.
+ *
+ * `skrr store install|show|stats`, `skrr agents share|badge` and `skrr open`
+ * read the positional through `resolveAgentRef`, never by using the raw string
+ * as an id. Accepted, in this order:
+ *
+ *   - an agent id, typed as-is (`agent_abc`) — no attribution: nobody shared it;
+ *   - any first-party link `parseSkrrLink` recognises as an agent
+ *     (`https://skrr.ai/a/<id>[/slug]`, `/store/agents/<id>`, `/agent/<id>`,
+ *     `skrr://agent/<id>`), keeping the link's own `?s=` / `?ch=`;
+ *   - a first-party link that carries only a share code (`/?s=<code>`), or
+ *     names something the CLI cannot look up locally but carries a code — the
+ *     code is resolved through the server (`resolveDistributionCode`);
+ *   - a vanity address, `@handle/agent-slug` or `…/@handle/agent-slug` — the
+ *     alias is resolved through the server's public vanity endpoint (a retired
+ *     handle or slug still resolves; agent-distribution-2026-10-08, "Vanity
+ *     URLs"). A vanity link that also carries a code is resolved by its code,
+ *     which names the agent exactly.
+ *
+ * Link recognition is data-provider's (`inspectSkrrLink`, principle 5): no
+ * regex here decides what a URL names.
+ *
+ * Attribution belongs to the SHARER's channel. A pasted link keeps the `ch` it
+ * was minted with; a bare id carries none, and this never invents one (no
+ * `ch=cli` for an id someone typed — that would credit a share nobody made).
+ */
+export type ResolvedAgentRef = {
+    agentId: string;
+    /**
+     * How it was given: an id, a link naming the agent, a share code the server
+     * resolved, or a vanity alias the server resolved.
+     */
+    source: 'id' | 'link' | 'code' | 'vanity';
+    attribution: Attribution;
+};
+export type AgentRefErrorCode = 'AGENT_REF_EMPTY' | 'AGENT_REF_UNSUPPORTED' | 'AGENT_REF_FOREIGN' | 'AGENT_REF_NOT_AN_AGENT' | 'AGENT_REF_VANITY_UNRESOLVED' | 'AGENT_REF_CODE_UNRESOLVED';
+export declare class AgentRefError extends Error {
+    readonly code: AgentRefErrorCode;
+    constructor(message: string, code: AgentRefErrorCode);
+}
+export type AgentRefOptions = {
+    /** The configured deployment; its hosts count as first-party besides the built-in list. */
+    baseURL?: string;
+    /** How a share code is resolved. Defaults to the anonymous public resolve endpoint. */
+    resolveCode?: (code: string) => Promise<ResolveDistributionCodeResponse | null>;
+    /** How a vanity alias is resolved. Defaults to the anonymous public vanity endpoint. */
+    resolveVanity?: (handle: string, slug: string) => Promise<ResolveAgentVanityResponse | null>;
+};
+/**
+ * The built-in first-party hosts plus every origin the configured deployment
+ * serves (a dev or self-hosted `baseURL` is first-party for its own user).
+ */
+export declare function cliFirstPartyHosts(baseURL?: string): string[];
+export declare function resolveAgentRef(input: string, options?: AgentRefOptions): Promise<ResolvedAgentRef>;
+/**
+ * The canonical public address of a resolved agent, keeping the attribution it
+ * arrived with — what a command prints when it echoes a link back (an install
+ * command, an `open`), so following the echo credits the same share.
+ */
+export declare function attributedListingUrl(baseURL: string, ref: Pick<ResolvedAgentRef, 'agentId' | 'attribution'>): string;
+/** The install body fields an attribution maps to; empty for an unattributed ref. */
+export declare function installAttribution(attribution: Attribution): {
+    distributionCode?: string;
+    channel?: DistributionChannel;
+};
+/** Quote a URL for a POSIX shell: `?` and `&` in an attributed link are metacharacters. */
+export declare function shellQuote(value: string): string;

package/dist/lib/agent-ref.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRefError = void 0;
+exports.cliFirstPartyHosts = cliFirstPartyHosts;
+exports.resolveAgentRef = resolveAgentRef;
+exports.attributedListingUrl = attributedListingUrl;
+exports.installAttribution = installAttribution;
+exports.shellQuote = shellQuote;
+const data_provider_1 = require("@skrr-ai/data-provider");
+const http_error_1 = require("./http-error");
+const web_url_1 = require("./web-url");
+class AgentRefError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'AgentRefError';
+    }
+}
+exports.AgentRefError = AgentRefError;
+/**
+ * An agent id is a single opaque token (`agent_…` today). Anything with a
+ * slash, a colon, whitespace or a dot is a link, a path or a typo — none of
+ * which may be sent to the API as if it were an id, because the server would
+ * answer "not found" and the person would conclude the agent does not exist.
+ */
+const AGENT_ID_TOKEN = /^[A-Za-z0-9_-]+$/;
+function hostOf(origin) {
+    try {
+        return new URL(origin).host.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The built-in first-party hosts plus every origin the configured deployment
+ * serves (a dev or self-hosted `baseURL` is first-party for its own user).
+ */
+function cliFirstPartyHosts(baseURL) {
+    const hosts = new Set(data_provider_1.FIRST_PARTY_HOSTS.map((host) => host.toLowerCase()));
+    if (baseURL) {
+        for (const origin of [baseURL, ...(0, web_url_1.firstPartyWebOrigins)(baseURL)]) {
+            const host = hostOf(origin);
+            if (host) {
+                hosts.add(host);
+                if (!host.startsWith('www.'))
+                    hosts.add(`www.${host}`);
+            }
+        }
+    }
+    return [...hosts];
+}
+async function defaultResolveCode(code) {
+    try {
+        return await data_provider_1.dataService.resolveDistributionCode(code);
+    }
+    catch (err) {
+        if ((0, http_error_1.httpStatusOf)(err) === 404)
+            return null;
+        throw err;
+    }
+}
+async function defaultResolveVanity(handle, slug) {
+    try {
+        return await data_provider_1.dataService.resolveAgentVanity({ handle, slug });
+    }
+    catch (err) {
+        if ((0, http_error_1.httpStatusOf)(err) === 404)
+            return null;
+        throw err;
+    }
+}
+async function resolveByVanity(value, handle, slug, attribution, options) {
+    const resolved = await (options.resolveVanity ?? defaultResolveVanity)(handle, slug);
+    if (resolved?.entity?.kind !== 'agent' || !resolved.entity.id) {
+        throw new AgentRefError(`No public agent answers to "${value}". The publisher may have unpublished it; their ` +
+            `page lists what they publish: skrr open ${(0, data_provider_1.entityPath)({ kind: 'publisher', handle })}`, 'AGENT_REF_VANITY_UNRESOLVED');
+    }
+    // An alias is an address, not a share: it carries no attribution of its own.
+    return { agentId: resolved.entity.id, source: 'vanity', attribution };
+}
+function withChannel(attribution, channel) {
+    if (attribution.channel)
+        return attribution;
+    const normalized = (0, data_provider_1.normalizeDistributionChannel)(channel);
+    return normalized ? { ...attribution, channel: normalized } : attribution;
+}
+async function resolveByCode(value, attribution, options) {
+    const code = attribution.code;
+    const resolved = await (options.resolveCode ?? defaultResolveCode)(code);
+    if (!resolved?.entity) {
+        throw new AgentRefError(`The share code in "${value}" does not point at a public agent: it may have been ` +
+            'unpublished, or the link was copied incompletely.', 'AGENT_REF_CODE_UNRESOLVED');
+    }
+    if (resolved.entity.kind !== 'agent') {
+        throw new AgentRefError(`"${value}" is a link to a ${resolved.entity.kind.replace(/_/g, ' ')}, not an agent.`, 'AGENT_REF_NOT_AN_AGENT');
+    }
+    return {
+        agentId: resolved.entity.id,
+        source: 'code',
+        // The link's own `ch` wins; the code's minted channel fills a link without one.
+        attribution: withChannel(attribution, resolved.channel),
+    };
+}
+async function resolveAgentRef(input, options = {}) {
+    const value = String(input ?? '').trim();
+    if (!value) {
+        throw new AgentRefError(`Name the agent: pass its id (agent_…) or a ${data_provider_1.BRAND.displayName} link to it.`, 'AGENT_REF_EMPTY');
+    }
+    if (AGENT_ID_TOKEN.test(value)) {
+        return { agentId: value, source: 'id', attribution: {} };
+    }
+    const inspected = (0, data_provider_1.inspectSkrrLink)(value, {
+        firstPartyHosts: cliFirstPartyHosts(options.baseURL),
+    });
+    if (!inspected) {
+        throw /^[a-z][a-z0-9+.-]*:\/\//i.test(value)
+            ? new AgentRefError(`"${value}" is not a ${data_provider_1.BRAND.displayName} link, so it was not followed. Pass an agent ` +
+                `id or a link on ${data_provider_1.BRAND.displayName}'s own site.`, 'AGENT_REF_FOREIGN')
+            : unsupported(value);
+    }
+    const { link, attribution } = inspected;
+    switch (link.kind) {
+        case 'agent':
+        case 'store_agent':
+        case 'agent_owner':
+            return { agentId: link.agentId, source: 'link', attribution };
+        case 'agent_vanity':
+            // A code on the link names the agent exactly; a bare alias is resolved
+            // by the server's vanity store.
+            if (attribution.code)
+                return resolveByCode(value, attribution, options);
+            return resolveByVanity(value, link.handle, link.slug, attribution, options);
+        case 'unknown':
+            if (attribution.code)
+                return resolveByCode(value, attribution, options);
+            throw unsupported(value);
+        default:
+            throw new AgentRefError(`"${value}" is a link to a ${link.kind.replace(/_/g, ' ')}, not an agent.`, 'AGENT_REF_NOT_AN_AGENT');
+    }
+}
+function unsupported(value) {
+    return new AgentRefError(`"${value}" is not an agent id or a link to an agent. Pass the id (agent_…) or its ` +
+        'listing link (…/a/<id>).', 'AGENT_REF_UNSUPPORTED');
+}
+/**
+ * The canonical public address of a resolved agent, keeping the attribution it
+ * arrived with — what a command prints when it echoes a link back (an install
+ * command, an `open`), so following the echo credits the same share.
+ */
+function attributedListingUrl(baseURL, ref) {
+    return (0, data_provider_1.buildShareUrl)((0, web_url_1.webOrigin)(baseURL), { kind: 'agent', id: ref.agentId }, {
+        code: ref.attribution.code,
+        channel: ref.attribution.channel,
+    });
+}
+/** The install body fields an attribution maps to; empty for an unattributed ref. */
+function installAttribution(attribution) {
+    return {
+        ...(attribution.code ? { distributionCode: attribution.code } : {}),
+        ...(attribution.channel ? { channel: attribution.channel } : {}),
+    };
+}
+/** Quote a URL for a POSIX shell: `?` and `&` in an attributed link are metacharacters. */
+function shellQuote(value) {
+    return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/lib/api-fetch.d.ts

@@ -37,6 +37,8 @@ export declare class ApiFetchError extends Error {
      * attributed by guesswork — see `node-adapter.ts`.
      */
     readonly requestId?: string;
+    /** Milliseconds the server asked us to wait (`Retry-After`) on a 429. */
+    retryAfterMs?: number;
     /**
      * Set on a 401 when this CLI's own refresh was refused AND the local
      * daemon, asked for a hand-off, refused too (OSK-12474). The daemon's reason

package/dist/lib/api-fetch.js

@@ -47,6 +47,7 @@ const daemonBroker_1 = require("./daemonBroker");
 const dpop_auth_1 = require("./dpop-auth");
 const workspace_header_1 = require("./workspace-header");
 const non_json_response_1 = require("./non-json-response");
+const rate_limit_retry_1 = require("./rate-limit-retry");
 class ApiFetchError extends Error {
     status;
     body;
@@ -63,6 +64,8 @@ class ApiFetchError extends Error {
      * attributed by guesswork — see `node-adapter.ts`.
      */
     requestId;
+    /** Milliseconds the server asked us to wait (`Retry-After`) on a 429. */
+    retryAfterMs;
     /**
      * Set on a 401 when this CLI's own refresh was refused AND the local
      * daemon, asked for a hand-off, refused too (OSK-12474). The daemon's reason
@@ -186,13 +189,19 @@ async function apiFetch(pathOrUrl, opts = {}) {
         // OSK-12020 — a fresh proof per attempt for a DPoP-bound hand-off token
         // (the 401 retry below re-enters here and gets its own). No-op otherwise.
         Object.assign(headers, await (0, dpop_auth_1.dpopHeadersFor)(credential.token, method, url));
-        return fetch(url, {
+        const sent = (0, workspace_header_1.withWorkspaceHeader)(headers);
+        // E6: a 429 on a GET or an idempotency-keyed write is retried (bounded,
+        // jittered, honouring Retry-After). The last 429's wait is kept for the error.
+        const { response, retryAfterMs } = await (0, rate_limit_retry_1.fetchWithRateLimitRetry)(() => fetch(url, {
             method,
-            headers: (0, workspace_header_1.withWorkspaceHeader)(headers),
+            headers: sent,
             body,
             ...(opts.signal ? { signal: opts.signal } : {}),
-        });
+        }), { method, headers: sent, signal: opts.signal });
+        lastRetryAfterMs = retryAfterMs;
+        return response;
     };
+    let lastRetryAfterMs;
     let res = await fetchWithCredential(cred);
     let brokerFailure = null;
     if (res.status === 401 && delegatedCli) {
@@ -271,6 +280,8 @@ async function apiFetch(pathOrUrl, opts = {}) {
         const error = new ApiFetchError(`HTTP ${res.status} ${res.statusText} — ${method} ${pathOrUrl}`, res.status, text, code, method, res.headers.get('x-request-id') || undefined);
         if (brokerFailure)
             error.brokerFailure = brokerFailure;
+        if (res.status === 429 && lastRetryAfterMs !== undefined)
+            error.retryAfterMs = lastRetryAfterMs;
         throw error;
     }
     // 204/205 carry no body by definition; an empty body has no content-type

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

@@ -26,6 +26,8 @@ export type CommandHygieneReport = {
         domains: number;
         budgetErrors: number;
     };
+    /** The verb rules the findings below are measured against (P8). */
+    namingGrammar: readonly string[];
     issues: CommandHygieneIssue[];
 };
 export declare function auditCommands({ rootDir, manifest, }: {
@@ -37,3 +39,14 @@ export declare function auditCommands({ rootDir, manifest, }: {
      */
     manifest?: CommandManifest;
 }): CommandHygieneReport;
+/**
+ * The domains an agent drives most. A missing description or `--json` output
+ * here is a build error (P10); elsewhere it stays a warning until that domain's
+ * offenders are fixed, so the gate can ratchet outward one domain at a time.
+ */
+export declare const ENFORCED_HYGIENE_DOMAINS: readonly ["tasks", "spaces", "projects"];
+/**
+ * The verb grammar `commands --audit` checks, stated once so a reader of the
+ * report sees the rule and not only the findings it produced.
+ */
+export declare const NAMING_GRAMMAR: readonly ["Verbs: list, show, create, update, delete, archive, unarchive, move. A reversible state flip is its own verb, never a flag on its inverse.", "Scope: a list verb takes its parent scope as an optional filter flag; a verb that cannot work without a scope says so in its description.", "Output: every command in tasks, spaces and projects takes --json and has a description (audit errors)."];

package/dist/lib/command-hygiene.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAMING_GRAMMAR = exports.ENFORCED_HYGIENE_DOMAINS = void 0;
 exports.auditCommands = auditCommands;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -120,6 +121,32 @@ function auditCommands({ rootDir, manifest, }) {
                     });
                 }
             }
+            // Without a generated manifest (a source checkout, most CI jobs) the
+            // manifest rules below never run, so the P10 gate for tasks/spaces/projects
+            // would pass by not looking. Read the same two facts off the source.
+            if (!manifest && isEnforcedDomain(command)) {
+                // A spread of a shared flag set (`...paginatedExportFlags(...)`) may carry
+                // --json from another file; only the manifest can tell, so do not guess.
+                const spreadsSharedFlags = /\.\.\.[\w.]*Flags\b/.test(source);
+                if (!hasJson && !spreadsSharedFlags && isMachineRelevantCommand(command)) {
+                    issues.push({
+                        code: 'JSON_SUCCESS_OUTPUT_MISSING',
+                        severity: 'error',
+                        command,
+                        file: rel,
+                        message: 'Machine-relevant command has no --json success-output flag. Keep human-only commands intentional.',
+                    });
+                }
+                if (!/static (?:override )?description\s*=/.test(source)) {
+                    issues.push({
+                        code: 'COMMAND_DESCRIPTION_MISSING',
+                        severity: 'error',
+                        command,
+                        file: rel,
+                        message: 'Command is missing a description.',
+                    });
+                }
+            }
             if (hasFromJson && !hasJson) {
                 issues.push({
                     code: 'FROM_JSON_WITHOUT_JSON_OUTPUT',
@@ -153,7 +180,7 @@ function auditCommands({ rootDir, manifest, }) {
             if (!command?.description?.trim()) {
                 issues.push({
                     code: 'COMMAND_DESCRIPTION_MISSING',
-                    severity: 'warning',
+                    severity: isEnforcedDomain(id) ? 'error' : 'warning',
                     command: id,
                     message: 'Command is missing a description in the manifest.',
                 });
@@ -161,11 +188,22 @@ function auditCommands({ rootDir, manifest, }) {
             if (!hasJsonFlag(command?.flags) && isMachineRelevantCommand(id)) {
                 issues.push({
                     code: 'JSON_SUCCESS_OUTPUT_MISSING',
-                    severity: 'warning',
+                    severity: isEnforcedDomain(id) ? 'error' : 'warning',
                     command: id,
                     message: 'Machine-relevant command has no --json success-output flag. Keep human-only commands intentional.',
                 });
             }
+            // P8: a state flip is a verb (`archive` / `unarchive`), not a flag on its
+            // inverse. `spaces unarchive` follows the grammar; `tasks archive
+            // --unarchive` and `projects archive --unarchive` do not.
+            if (isEnforcedDomain(id) && hasFlag(command?.flags, 'unarchive')) {
+                issues.push({
+                    code: 'VERB_GRAMMAR_INVERSE_AS_FLAG',
+                    severity: 'warning',
+                    command: id,
+                    message: `Naming grammar: a state flip is its own verb (\`${id.replace(/:archive$/, ':unarchive').replace(/:/g, ' ')}\`), not --unarchive on the forward verb. Keep the flag as a deprecated alias when adding the verb.`,
+                });
+            }
         }
     }
     const errors = issues.filter((issue) => issue.severity === 'error').length;
@@ -190,6 +228,7 @@ function auditCommands({ rootDir, manifest, }) {
             domains: (0, usage_discovery_1.usageDomains)(manifestForCatalog).length,
             budgetErrors: usageBudgetIssues.length,
         },
+        namingGrammar: exports.NAMING_GRAMMAR,
         issues,
     };
 }
@@ -213,6 +252,27 @@ function commandIdFromRelativePath(relativePath) {
 function hasJsonFlag(flags) {
     return Boolean(flags && typeof flags === 'object' && 'json' in flags);
 }
+/**
+ * The domains an agent drives most. A missing description or `--json` output
+ * here is a build error (P10); elsewhere it stays a warning until that domain's
+ * offenders are fixed, so the gate can ratchet outward one domain at a time.
+ */
+exports.ENFORCED_HYGIENE_DOMAINS = ['tasks', 'spaces', 'projects'];
+function isEnforcedDomain(id) {
+    return exports.ENFORCED_HYGIENE_DOMAINS.some((domain) => id === domain || id.startsWith(`${domain}:`));
+}
+function hasFlag(flags, name) {
+    return Boolean(flags && typeof flags === 'object' && name in flags);
+}
+/**
+ * The verb grammar `commands --audit` checks, stated once so a reader of the
+ * report sees the rule and not only the findings it produced.
+ */
+exports.NAMING_GRAMMAR = [
+    'Verbs: list, show, create, update, delete, archive, unarchive, move. A reversible state flip is its own verb, never a flag on its inverse.',
+    'Scope: a list verb takes its parent scope as an optional filter flag; a verb that cannot work without a scope says so in its description.',
+    'Output: every command in tasks, spaces and projects takes --json and has a description (audit errors).',
+];
 function isMachineRelevantCommand(id) {
     return !(id === 'login' ||
         id === 'logout' ||

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

@@ -1,4 +1,4 @@
-import { type DedicatedRuntimePowerSummary, type DedicatedPowerPolicy, type DedicatedRuntimePowerPolicyState, type OnDemandIneligibleError, type SetDedicatedRuntimePowerPolicyResponse } from '@skrr-ai/data-provider';
+import { type DedicatedRuntimePowerSummary, type DedicatedRuntimeWaitingWork, type DedicatedPowerPolicy, type DedicatedRuntimePowerPolicyState, type OnDemandIneligibleError, type SetDedicatedRuntimePowerPolicyResponse } from '@skrr-ai/data-provider';
 import { type WhenOptions } from './format';
 import { type DedicatedRuntimeScope } from './dedicated-machines';
 /**
@@ -33,6 +33,16 @@ export declare function describePolicyWords(policy: DedicatedPowerPolicy, idleAf
 export declare function describePowerPolicy(power: DedicatedRuntimePowerPolicyState, autoStopMode?: 'off' | 'canary' | 'on'): string;
 /** `GET /api/machines/dedicated/:leaseId/power` — the read-only power card. */
 export declare function getDedicatedPowerSummary(leaseId: string, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimePowerSummary>;
+/** `GET /api/machines/dedicated/:leaseId/power/waiting` — work waiting for this machine. */
+export declare function getDedicatedWaitingWork(leaseId: string, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimeWaitingWork>;
+/** The lines of `power waiting`. An unreadable source is said, never folded into "nothing waiting". */
+export declare function describeWaitingWork(waiting: DedicatedRuntimeWaitingWork, when?: WhenOptions): string[];
+/** Last wake timing. A wake that never became assignable shows the phases it reached and no latency. */
+export declare function describeLastWakeTiming(wake: DedicatedRuntimePowerSummary['lastWake']): string[];
+/** on_demand availability, so a plan does not need a failed `power set` to find out. */
+export declare function describeOnDemandAvailability(onDemand: DedicatedRuntimePowerSummary['onDemand']): string[];
+/** Pre-warm lines: only a PAUSED pre-warm is in the summary, so silence here is not "pre-warm is on". */
+export declare function describePrewarm(prewarm: DedicatedRuntimePowerSummary['prewarm'], when?: WhenOptions): string[];
 type PowerDecisionView = NonNullable<DedicatedRuntimePowerSummary['decision']>;
 /** The stay/stop/wake decision in words: the shared reason copy backs the server's detail. */
 export declare function describePowerDecisionLines(decision: PowerDecisionView): {
@@ -53,6 +63,11 @@ export declare function describeLastAutoStopLines(last: DedicatedRuntimePowerSum
 };
 /** The latest wake decision and who asked, as lines; empty when there is none. */
 export declare function describeLastWakeDecisionLines(wake: DedicatedRuntimePowerSummary['lastWakeDecision'], when?: WhenOptions): string[];
+/**
+ * The announced-but-not-yet-done stop, in the shared words (`describePendingStop`). Empty when the
+ * summary carries none, which is also what an older server sends: absent is not "no stop coming".
+ */
+export declare function describePendingStopLines(summary: Pick<DedicatedRuntimePowerSummary, 'leaseId' | 'pendingStop'>, when?: WhenOptions): string[];
 /** The lines of `power show`. */
 export declare function describePowerSummary(summary: DedicatedRuntimePowerSummary, when?: WhenOptions): string[];
 /** The lines of `power explain`; the fix is always last. */