@skrr-ai/cli 0.1.88 → 0.1.90

package/dist/lib/commitments.d.ts

@@ -744,7 +744,7 @@ export declare function describeAutonomyLine(commitment: CommitmentView, latestC
 } | null): string;
 /**
  * One-line rendering of `commitment.executorBlocked` — the B4/A7 signal that
- * the executor's targets are all unusable: `{reason:'quota'|'offline', until?,
+ * the executor's targets are all unusable: `{reason:'quota'|'offline'|'waiting_for_machine', until?,
  * provider?}`.
  *
  * Defensive by contract: the field is being added server-side, so its absence

package/dist/lib/commitments.js

@@ -874,7 +874,7 @@ function describeAutonomyLine(commitment, latestCheck) {
 }
 /**
  * One-line rendering of `commitment.executorBlocked` — the B4/A7 signal that
- * the executor's targets are all unusable: `{reason:'quota'|'offline', until?,
+ * the executor's targets are all unusable: `{reason:'quota'|'offline'|'waiting_for_machine', until?,
  * provider?}`.
  *
  * Defensive by contract: the field is being added server-side, so its absence
@@ -893,7 +893,9 @@ function describeExecutorBlocked(commitment) {
         ? `quota exhausted${provider ? ` on ${provider}` : ''}`
         : reason === 'offline'
             ? 'executor runtime offline'
-            : reason || 'blocked';
+            : reason === 'waiting_for_machine'
+                ? 'executor machine is stopped and will be started for the work'
+                : reason || 'blocked';
     return `${label}${until ? ` until ${until}` : ''}`;
 }
 function renderCommitmentSummary(commitment, log, 

package/dist/lib/computer-adoption.d.ts

@@ -45,6 +45,11 @@ export interface ComputerAdoption {
         oldFamilies: string[];
         daemonHalfMet: boolean | null;
         mobileHalfMet?: boolean | null;
+        /** Set once the families were retired; absent from a server before OSK-13509. */
+        retired?: {
+            on: string;
+            reason: string;
+        };
     };
 }
 /**

package/dist/lib/computer-adoption.js

@@ -61,7 +61,12 @@ function computerAdoptionLines(read) {
         verdict = 'not measurable: no active daemons';
     else if (criterion.daemonHalfMet)
         verdict = 'MET';
-    lines.push('', `Retirement of ${criterion.oldFamilies.join(', ')}`, `  daemon half (< ${(criterion.maxLegacyOnlyShare * 100).toFixed(0)}% of daemons active in ${criterion.windowDays} days on the old families only): ${verdict}`, mobileHalfLine(read));
+    lines.push('', `Retirement of ${criterion.oldFamilies.join(', ')}`);
+    if (criterion.retired) {
+        // The families are gone: the counts above are who it stranded, not who is still served.
+        lines.push(`  RETIRED ${criterion.retired.on}: ${criterion.retired.reason}`, '  old-families-only daemons above can reach no terminal or browser; each is told to update when it registers');
+    }
+    lines.push(`  daemon half (< ${(criterion.maxLegacyOnlyShare * 100).toFixed(0)}% of daemons active in ${criterion.windowDays} days on the old families only): ${verdict}`, mobileHalfLine(read));
     lines.push(...clientLines(read));
     return lines;
 }

package/dist/lib/computer-consent.d.ts

@@ -1,4 +1,5 @@
 import { Command } from '@oclif/core';
+import { type RuntimeBinaryOutput } from './exec-runtime-binary';
 /**
  * The bridge for `skrr computer` — the machine-local consent for the
  * computer's new surfaces on a personal machine (design §18, D11;
@@ -10,4 +11,45 @@ import { Command } from '@oclif/core';
  * Keeping the CLI a thin forwarder preserves that boundary: `skrr` carries
  * the verb to the same binary `skrrd` runs it on.
  */
-export declare function forwardComputerConsent(command: Command, passthrough: readonly string[]): Promise<void>;
+/** Bound on the `skrrd status --json` probe: it is a read, and must never stall the command. */
+export declare const DAEMON_STATUS_PROBE_TIMEOUT_MS = 8000;
+/** What `skrrd status --json` says about the daemon that would answer. */
+export interface AnsweringDaemon {
+    /** The binary `skrr` forwards to. */
+    binary: string | null;
+    /** The on-disk binary's version (`statusCommandVersion`), when it said. */
+    binaryVersion: string | null;
+    /** The running daemon's version (`liveVersion`/`version`), when it said. */
+    runningVersion: string | null;
+    daemonId: string | null;
+    profile: string | null;
+    /** `update.state` — `source-build`, `update-available`, `restart-pending`, … */
+    updateState: string | null;
+    /** `update.commands`: the install-method-correct way to update THIS daemon. */
+    updateCommands: string[];
+    restartPending: boolean;
+}
+export interface ComputerConsentDeps {
+    supportsSubcommand: (subcommand: string) => Promise<boolean | null>;
+    exec: (args: string[]) => Promise<number>;
+    capture: (args: string[], opts?: {
+        timeoutMs?: number;
+    }) => Promise<RuntimeBinaryOutput>;
+    findBinary: () => string | null;
+}
+/**
+ * Read `skrrd status --json` for the facts a person needs to know WHICH daemon
+ * answered and how it updates. Null when the status cannot be read — the
+ * caller then says what it can without inventing the rest.
+ */
+export declare function readAnsweringDaemon(passthrough?: readonly string[], deps?: ComputerConsentDeps): Promise<AnsweringDaemon | null>;
+/** "skrrd 0.8.103 at /path (daemon_…, running 0.8.90)" — whatever of that is known. */
+export declare function describeAnsweringDaemon(daemon: AnsweringDaemon | null, binary: string | null): string;
+/**
+ * What to tell a person whose local daemon has no `computer` verb: which
+ * daemon answered, and the update path for THAT install (OSK-13822). A source
+ * build updates by rebuilding its checkout — `skrrd status --json` already
+ * carries that recipe under `update.commands` — not by reinstalling.
+ */
+export declare function computerUnsupportedMessage(daemon: AnsweringDaemon | null, binary: string | null): string;
+export declare function forwardComputerConsent(command: Command, passthrough: readonly string[], deps?: ComputerConsentDeps): Promise<void>;

package/dist/lib/computer-consent.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_STATUS_PROBE_TIMEOUT_MS = void 0;
+exports.readAnsweringDaemon = readAnsweringDaemon;
+exports.describeAnsweringDaemon = describeAnsweringDaemon;
+exports.computerUnsupportedMessage = computerUnsupportedMessage;
 exports.forwardComputerConsent = forwardComputerConsent;
 const exec_runtime_binary_1 = require("./exec-runtime-binary");
 /**
@@ -13,15 +17,132 @@ const exec_runtime_binary_1 = require("./exec-runtime-binary");
  * Keeping the CLI a thin forwarder preserves that boundary: `skrr` carries
  * the verb to the same binary `skrrd` runs it on.
  */
-async function forwardComputerConsent(command, passthrough) {
+/** Bound on the `skrrd status --json` probe: it is a read, and must never stall the command. */
+exports.DAEMON_STATUS_PROBE_TIMEOUT_MS = 8_000;
+const defaultDeps = {
+    supportsSubcommand: exec_runtime_binary_1.runtimeBinarySupportsSubcommand,
+    exec: (args) => (0, exec_runtime_binary_1.execRuntimeBinary)(args),
+    capture: (args, opts) => (0, exec_runtime_binary_1.execRuntimeBinaryCapture)(args, opts),
+    findBinary: exec_runtime_binary_1.findRuntimeBinary,
+};
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+/**
+ * Read `skrrd status --json` for the facts a person needs to know WHICH daemon
+ * answered and how it updates. Null when the status cannot be read — the
+ * caller then says what it can without inventing the rest.
+ */
+async function readAnsweringDaemon(passthrough = [], deps = defaultDeps) {
+    let output;
+    try {
+        output = await deps.capture([...profileArgs(passthrough), 'status', '--json'], {
+            timeoutMs: exports.DAEMON_STATUS_PROBE_TIMEOUT_MS,
+        });
+    }
+    catch {
+        return null;
+    }
+    let status;
+    try {
+        status = JSON.parse(output.stdout);
+    }
+    catch {
+        return null;
+    }
+    if (!status || typeof status !== 'object')
+        return null;
+    const update = status.update && typeof status.update === 'object'
+        ? status.update
+        : {};
+    return {
+        binary: deps.findBinary(),
+        binaryVersion: text(status.statusCommandVersion),
+        runningVersion: text(status.liveVersion) ?? text(status.version),
+        daemonId: text(status.daemonId),
+        profile: text(status.profile),
+        updateState: text(update.state),
+        updateCommands: Array.isArray(update.commands)
+            ? update.commands.filter((c) => typeof c === 'string' && c.trim() !== '')
+            : [],
+        restartPending: update.restartPending === true,
+    };
+}
+/** `--profile <name>` from the pass-through, so the status probe asks the same daemon. */
+function profileArgs(passthrough) {
+    for (let i = 0; i < passthrough.length; i += 1) {
+        const arg = passthrough[i];
+        if (arg === '--profile' && passthrough[i + 1])
+            return ['--profile', passthrough[i + 1]];
+        if (arg.startsWith('--profile='))
+            return ['--profile', arg.slice('--profile='.length)];
+    }
+    return [];
+}
+/** "skrrd 0.8.103 at /path (daemon_…, running 0.8.90)" — whatever of that is known. */
+function describeAnsweringDaemon(daemon, binary) {
+    const where = daemon?.binary ?? binary;
+    const parts = [];
+    parts.push(`${where ?? 'skrrd'}${daemon?.binaryVersion ? ` (v${daemon.binaryVersion} on disk)` : ''}`);
+    if (daemon?.runningVersion && daemon.runningVersion !== daemon.binaryVersion) {
+        parts.push(`running daemon v${daemon.runningVersion}`);
+    }
+    else if (daemon?.runningVersion && !daemon.binaryVersion) {
+        parts.push(`v${daemon.runningVersion}`);
+    }
+    if (daemon?.daemonId)
+        parts.push(daemon.daemonId);
+    return parts.join(', ');
+}
+/**
+ * What to tell a person whose local daemon has no `computer` verb: which
+ * daemon answered, and the update path for THAT install (OSK-13822). A source
+ * build updates by rebuilding its checkout — `skrrd status --json` already
+ * carries that recipe under `update.commands` — not by reinstalling.
+ */
+function computerUnsupportedMessage(daemon, binary) {
+    const lines = [
+        `The local daemon does not support \`skrr computer\` yet: ${describeAnsweringDaemon(daemon, binary)}.`,
+    ];
+    if (daemon?.updateState === 'source-build') {
+        const recipe = daemon.updateCommands.length
+            ? daemon.updateCommands
+            : ['cd <daemon-dir> && git pull && npm run build'];
+        lines.push('It runs from a source checkout, which updates by rebuilding:');
+        for (const command of recipe)
+            lines.push(`  ${command}`);
+        lines.push('Then restart it:', '  skrr daemon restart');
+    }
+    else if (daemon?.restartPending) {
+        lines.push('A newer daemon is already on disk; the running one predates it. Restart it:', '  skrr daemon restart');
+    }
+    else if (daemon && daemon.updateCommands.length > 0) {
+        lines.push('Update it:');
+        for (const command of daemon.updateCommands)
+            lines.push(`  ${command}`);
+        lines.push('Then restart it:', '  skrr daemon restart');
+    }
+    else {
+        lines.push('Update it (`skrr daemon update`, or reinstall it), restart it (`skrr daemon restart`), then retry.');
+    }
+    return lines.join('\n');
+}
+async function forwardComputerConsent(command, passthrough, deps = defaultDeps) {
     try {
         // Older daemons treated unknown subcommands as a daemon startup in some
         // releases. Probe the command list before forwarding so a consent verb
         // cannot turn into a surprising service mutation.
-        if ((await (0, exec_runtime_binary_1.runtimeBinarySupportsSubcommand)('computer')) === false) {
-            command.error('The local `skrrd` daemon does not support `skrr computer` yet. Update or reinstall the daemon, then retry.', { exit: 2 });
+        if ((await deps.supportsSubcommand('computer')) === false) {
+            const daemon = await readAnsweringDaemon(passthrough, deps);
+            command.error(computerUnsupportedMessage(daemon, deps.findBinary()), { exit: 2 });
+        }
+        if (passthrough.includes('status')) {
+            // Which daemon answered, before its answer — on stderr, so `--json`
+            // output stays exactly what the daemon printed.
+            const daemon = await readAnsweringDaemon(passthrough, deps);
+            command.logToStderr(`Answered by: ${describeAnsweringDaemon(daemon, deps.findBinary())}`);
         }
-        command.exit(await (0, exec_runtime_binary_1.execRuntimeBinary)(['computer', ...passthrough]));
+        command.exit(await deps.exec(['computer', ...passthrough]));
     }
     catch (error) {
         if (error.message === 'runtime-binary-not-installed') {

package/dist/lib/dedicated-keep-awake.d.ts

@@ -0,0 +1,19 @@
+import { type DedicatedRuntimeKeepAwakeResponse, type DedicatedRuntimeKeepAwakeState, type SetDedicatedRuntimeKeepAwakeRequest } from '@skrr-ai/data-provider';
+import { type WhenOptions } from './format';
+import { type DedicatedRuntimeScope } from './dedicated-machines';
+/**
+ * Domain lib for `skrr machines dedicated power keep-awake` (K1). Keep-awake is a
+ * temporary override that forbids AUTOMATIC stop; it never starts the machine.
+ * The web calls the same routes through `dataService.setDedicatedRuntimeKeepAwake`.
+ */
+export declare function setDedicatedKeepAwake(leaseId: string, request: SetDedicatedRuntimeKeepAwakeRequest, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimeKeepAwakeResponse>;
+export declare function clearDedicatedKeepAwake(leaseId: string, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimeKeepAwakeResponse>;
+/**
+ * `--for` takes a whole number with a unit: `90m`, `2h`, `3d`. A bare number is
+ * minutes (the unit the API speaks). Returns minutes, or throws a plain message.
+ */
+export declare function parseKeepAwakeDuration(value: string): number;
+export declare function assertKeepAwakeMinutes(minutes: number): void;
+/** `--until` takes any ISO 8601 date. The server re-checks the bounds. */
+export declare function parseKeepAwakeUntil(value: string): string;
+export declare function describeKeepAwake(state: DedicatedRuntimeKeepAwakeState, when?: WhenOptions): string;

package/dist/lib/dedicated-keep-awake.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDedicatedKeepAwake = setDedicatedKeepAwake;
+exports.clearDedicatedKeepAwake = clearDedicatedKeepAwake;
+exports.parseKeepAwakeDuration = parseKeepAwakeDuration;
+exports.assertKeepAwakeMinutes = assertKeepAwakeMinutes;
+exports.parseKeepAwakeUntil = parseKeepAwakeUntil;
+exports.describeKeepAwake = describeKeepAwake;
+const data_provider_1 = require("@skrr-ai/data-provider");
+const api_fetch_1 = require("./api-fetch");
+const format_1 = require("./format");
+const dedicated_machines_1 = require("./dedicated-machines");
+/**
+ * Domain lib for `skrr machines dedicated power keep-awake` (K1). Keep-awake is a
+ * temporary override that forbids AUTOMATIC stop; it never starts the machine.
+ * The web calls the same routes through `dataService.setDedicatedRuntimeKeepAwake`.
+ */
+function setDedicatedKeepAwake(leaseId, request, scope = {}) {
+    return (0, api_fetch_1.apiFetch)((0, dedicated_machines_1.withDedicatedScope)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/power/keep-awake`, scope), {
+        method: 'PUT',
+        body: request,
+    });
+}
+function clearDedicatedKeepAwake(leaseId, scope = {}) {
+    return (0, api_fetch_1.apiFetch)((0, dedicated_machines_1.withDedicatedScope)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/power/keep-awake`, scope), {
+        method: 'DELETE',
+    });
+}
+/**
+ * `--for` takes a whole number with a unit: `90m`, `2h`, `3d`. A bare number is
+ * minutes (the unit the API speaks). Returns minutes, or throws a plain message.
+ */
+function parseKeepAwakeDuration(value) {
+    const match = value.trim().match(/^(\d+)\s*(m|h|d)?$/i);
+    if (!match) {
+        throw new Error(`Invalid --for value "${value}". Use a number with m, h or d, such as 90m, 2h or 3d.`);
+    }
+    const amount = Number(match[1]);
+    const unit = (match[2] || 'm').toLowerCase();
+    const minutes = unit === 'd' ? amount * 1440 : unit === 'h' ? amount * 60 : amount;
+    assertKeepAwakeMinutes(minutes);
+    return minutes;
+}
+function assertKeepAwakeMinutes(minutes) {
+    if (minutes < data_provider_1.DEDICATED_KEEP_AWAKE_MINUTES_MIN) {
+        throw new Error(`Keep-awake must last at least ${data_provider_1.DEDICATED_KEEP_AWAKE_MINUTES_MIN} minutes.`);
+    }
+    if (minutes > data_provider_1.DEDICATED_KEEP_AWAKE_MINUTES_MAX) {
+        throw new Error(`Keep-awake can last at most ${data_provider_1.DEDICATED_KEEP_AWAKE_MINUTES_MAX / 1440} days. For longer, use \`power set --policy always_on\`.`);
+    }
+}
+/** `--until` takes any ISO 8601 date. The server re-checks the bounds. */
+function parseKeepAwakeUntil(value) {
+    const at = new Date(value);
+    if (Number.isNaN(at.getTime())) {
+        throw new Error(`Invalid --until value "${value}". Use an ISO date such as 2026-10-10T18:00:00Z.`);
+    }
+    return at.toISOString();
+}
+function describeKeepAwake(state, when = {}) {
+    return state.active && state.until
+        ? `is kept awake until ${(0, format_1.formatWhen)(state.until, when)}`
+        : 'has no keep-awake; it follows its power policy';
+}

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

@@ -358,6 +358,34 @@ export declare function restoreDeletedDedicatedRuntime(leaseId: string, options?
  * on the next reconciler pass.
  */
 export declare function setDedicatedRuntimeSpendingLimit(leaseId: string, spendingLimitCents: number | null, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimeResponse>;
+/**
+ * Whether the agents working on a Dedicated Runtime get a browser (OSK-13809).
+ *
+ * `state` is the machine's setting; `offered` is whether its CONNECTED daemon
+ * offers the browser right now (null: nothing connected, or unreadable). The
+ * two differ after a change until the daemon reconnects, and on an image
+ * without Chrome, which never offers it.
+ */
+export type DedicatedAgentBrowserState = {
+    leaseId: string;
+    state: 'on' | 'off' | 'pending_first_start';
+    enabled: boolean;
+    offered: boolean | null;
+    capability: string;
+    changed?: boolean;
+    effectiveOnNextReconnect?: boolean;
+};
+export declare function getDedicatedRuntimeAgentBrowser(leaseId: string, scope?: DedicatedRuntimeScope): Promise<DedicatedAgentBrowserState>;
+/** Turn the agents' browser on or off. An actual change is in the machine's audit record. */
+export declare function setDedicatedRuntimeAgentBrowser(leaseId: string, enabled: boolean, scope?: DedicatedRuntimeScope): Promise<DedicatedAgentBrowserState>;
+/**
+ * One line for a person. Says the bad cases out loud: a setting that is on
+ * while the connected daemon does not offer it yet, and a setting we could
+ * not read at all.
+ */
+export declare function describeDedicatedAgentBrowser(value: DedicatedAgentBrowserState | {
+    error: string;
+} | null | undefined, leaseId: string): string;
 export declare function closeDedicatedRuntimeIncidentHold(leaseId: string, options?: {
     requestId?: string;
 } & DedicatedRuntimeScope): Promise<DedicatedRuntimeResponse>;
@@ -627,6 +655,9 @@ export declare function dedicatedSpendSummary(lease: DedicatedLease): string;
 export declare function describeDedicatedDeletion(deletion: DedicatedLeaseDeletion, leaseId?: string): string;
 export declare function describeDedicatedLease(lease: DedicatedLease, harnesses?: readonly Harness[], opts?: {
     latestDaemonRelease?: LatestDaemonRelease | null;
+    agentBrowser?: DedicatedAgentBrowserState | {
+        error: string;
+    } | null;
 }): string[];
 /** "2026-09-30 14:00 UTC (in 17 days)" — a deadline readable without converting it. */
 export declare function formatDedicatedDeadline(value: string | null | undefined, now?: Date): string;

package/dist/lib/dedicated-machines.js

@@ -17,6 +17,9 @@ exports.performDedicatedLeaseAction = performDedicatedLeaseAction;
 exports.growDedicatedRuntime = growDedicatedRuntime;
 exports.restoreDeletedDedicatedRuntime = restoreDeletedDedicatedRuntime;
 exports.setDedicatedRuntimeSpendingLimit = setDedicatedRuntimeSpendingLimit;
+exports.getDedicatedRuntimeAgentBrowser = getDedicatedRuntimeAgentBrowser;
+exports.setDedicatedRuntimeAgentBrowser = setDedicatedRuntimeAgentBrowser;
+exports.describeDedicatedAgentBrowser = describeDedicatedAgentBrowser;
 exports.closeDedicatedRuntimeIncidentHold = closeDedicatedRuntimeIncidentHold;
 exports.destroyDedicatedRuntime = destroyDedicatedRuntime;
 exports.execDedicatedRuntime = execDedicatedRuntime;
@@ -368,6 +371,40 @@ async function restoreDeletedDedicatedRuntime(leaseId, options = {}) {
 async function setDedicatedRuntimeSpendingLimit(leaseId, spendingLimitCents, scope = {}) {
     return (0, api_fetch_1.apiFetch)(withDedicatedScope(`/api/machines/leases/${encodeURIComponent(leaseId)}/billing`, scope), { method: 'PATCH', body: { spendingLimitCents } });
 }
+async function getDedicatedRuntimeAgentBrowser(leaseId, scope = {}) {
+    return (0, api_fetch_1.apiFetch)(withDedicatedScope(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/agent-browser`, scope));
+}
+/** Turn the agents' browser on or off. An actual change is in the machine's audit record. */
+async function setDedicatedRuntimeAgentBrowser(leaseId, enabled, scope = {}) {
+    return (0, api_fetch_1.apiFetch)(withDedicatedScope(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/agent-browser`, scope), { method: 'PUT', body: { enabled } });
+}
+/**
+ * One line for a person. Says the bad cases out loud: a setting that is on
+ * while the connected daemon does not offer it yet, and a setting we could
+ * not read at all.
+ */
+function describeDedicatedAgentBrowser(value, leaseId) {
+    if (!value)
+        return 'unknown';
+    if ('error' in value)
+        return `unknown (could not read: ${value.error})`;
+    if (value.state === 'pending_first_start') {
+        return value.enabled
+            ? 'on when the machine first starts (the default for new machines)'
+            : 'off when the machine first starts';
+    }
+    if (value.state === 'off') {
+        return value.offered
+            ? `off — sessions already running keep theirs until the daemon reconnects (\`skrr machines dedicated restart ${leaseId}\`)`
+            : `off — turn on with \`skrr machines dedicated agent-browser ${leaseId} --on\``;
+    }
+    if (value.offered === true)
+        return 'on — every agent session can open one; you can watch and take it over';
+    if (value.offered === false) {
+        return `on, but the connected daemon does not offer it yet: it applies when the daemon reconnects (\`skrr machines dedicated restart ${leaseId}\`), and an image without Chrome never offers it`;
+    }
+    return 'on (not connected now, so whether the machine offers it is unknown)';
+}
 async function closeDedicatedRuntimeIncidentHold(leaseId, options = {}) {
     return (0, api_fetch_1.apiFetch)(withDedicatedScope(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/incident-hold/close`, options), {
         method: 'POST',
@@ -813,6 +850,9 @@ function describeDedicatedLease(lease, harnesses = [], opts = {}) {
         if (checkpoint)
             lines.push(`  ${''.padEnd(13)}${checkpoint.sentence}`);
     }
+    if (opts.agentBrowser !== undefined) {
+        row('agent browser', describeDedicatedAgentBrowser(opts.agentBrowser, dedicatedLeaseId(lease)));
+    }
     const engines = dedicatedLeaseHarnesses(lease, harnesses);
     if (engines.length > 0) {
         row('engines', engines.map((harness) => `${harness.provider} (${harness.status || 'unknown'})`).join(', '));

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

@@ -0,0 +1,61 @@
+import { type DedicatedRuntimePowerSummary, type DedicatedPowerPolicy, type DedicatedRuntimePowerPolicyState, type OnDemandIneligibleError, type SetDedicatedRuntimePowerPolicyResponse } from '@skrr-ai/data-provider';
+import { type WhenOptions } from './format';
+import { type DedicatedRuntimeScope } from './dedicated-machines';
+/**
+ * Domain lib for `skrr machines dedicated power …` (W6). Like its siblings in
+ * `dedicated-machines.ts` it speaks `apiFetch` so every refusal arrives as an
+ * `ApiFetchError` the Dedicated commands already know how to word; the route is
+ * covered by the machines parity spec through this file. The web calls the same
+ * route through `dataService.setDedicatedRuntimePowerPolicy`.
+ */
+export type SetPowerOutcome = {
+    ok: true;
+    response: SetDedicatedRuntimePowerPolicyResponse;
+} | {
+    ok: false;
+    refusal: OnDemandIneligibleError;
+};
+/**
+ * Set the policy. An ineligible `on_demand` is a RESULT, not an exception: the
+ * refusal is the answer the caller must explain (reason + fix). Every other
+ * failure is rethrown for the command's usual error handling.
+ */
+export declare function setDedicatedPowerPolicy(leaseId: string, request: {
+    policy?: DedicatedPowerPolicy;
+    idleAfterMinutes?: number;
+    budgetHoursPerMonth?: number | null;
+}, scope?: DedicatedRuntimeScope): Promise<SetPowerOutcome>;
+/**
+ * The policy in words. `on_demand` promises a stop only when the platform stops idle machines at all
+ * (`autoStopMode`); an unknown mode is never read as on, so the sentence never promises one.
+ */
+export declare function describePolicyWords(policy: DedicatedPowerPolicy, idleAfterMinutes: number, autoStopMode?: 'off' | 'canary' | 'on'): string;
+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>;
+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): {
+    headline: string;
+    detail: string;
+    fix: string | null;
+};
+/**
+ * The last automatic stop and how it was judged (A3). Every word comes from the shared copy
+ * (`describeAutoStopVerdict`, `describeMachineCheckpointOutcome`); nothing is composed here.
+ * `verdict: null` is "not judged yet", and is said so: it is never rendered as clean. A sentence
+ * the decision text already carries (the server appends it while the machine is stopped) is not
+ * repeated.
+ */
+export declare function describeLastAutoStopLines(last: DedicatedRuntimePowerSummary['lastAutoStop'], decisionDetail?: string, when?: WhenOptions): {
+    lines: string[];
+    fix: string | null;
+};
+/** 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 lines of `power show`. */
+export declare function describePowerSummary(summary: DedicatedRuntimePowerSummary, when?: WhenOptions): string[];
+/** The lines of `power explain`; the fix is always last. */
+export declare function describePowerExplanation(summary: DedicatedRuntimePowerSummary, when?: WhenOptions): string[];
+export declare function describeBudget(power: DedicatedRuntimePowerPolicyState): string;
+export {};