@skrr-ai/cli 0.1.88 → 0.1.89

package/dist/commands/machines/computer-adoption.d.ts

@@ -1,8 +1,9 @@
 import { BaseCommand } from '../../base-command';
 /**
  * `skrr machines computer-adoption` — the share of daemons still on the old
- * event families, which is the number retiring `browser:liveview:*` and
- * `agent:terminal:*` waits on (OSK-13578). Admin only on the server: it
+ * event families, the number retiring `browser:liveview:*` and
+ * `agent:terminal:*` waited on (OSK-13578). They are retired (OSK-13509), so it
+ * now counts who the retirement stranded. Admin only on the server: it
  * describes the fleet, not the caller.
  */
 export default class MachinesComputerAdoption extends BaseCommand {

package/dist/commands/machines/computer-adoption.js

@@ -5,12 +5,13 @@ const base_command_1 = require("../../base-command");
 const computer_adoption_1 = require("../../lib/computer-adoption");
 /**
  * `skrr machines computer-adoption` — the share of daemons still on the old
- * event families, which is the number retiring `browser:liveview:*` and
- * `agent:terminal:*` waits on (OSK-13578). Admin only on the server: it
+ * event families, the number retiring `browser:liveview:*` and
+ * `agent:terminal:*` waited on (OSK-13578). They are retired (OSK-13509), so it
+ * now counts who the retirement stranded. Admin only on the server: it
  * describes the fleet, not the caller.
  */
 class MachinesComputerAdoption extends base_command_1.BaseCommand {
-    static description = 'Show how many daemons are still on the old browser live view / agent terminal event families instead of the computer protocol, and whether the retirement criterion is met (admin only)';
+    static description = 'Show how many daemons are still on the old browser live view / agent terminal event families (now retired) instead of the computer protocol, and the retirement criterion (admin only)';
     static examples = [
         '<%= config.bin %> machines computer-adoption',
         '<%= config.bin %> machines computer-adoption --json',

package/dist/commands/machines/dedicated/agent-browser.d.ts

@@ -0,0 +1,25 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated agent-browser` — do the agents on this machine get a
+ * browser? (OSK-13809)
+ *
+ * A new Dedicated Runtime gives its agents a browser by default; a machine
+ * created before that decision keeps what it had. This is the one switch for
+ * both directions, per machine: `--off` takes it away and it stays away across
+ * restarts, image updates and replacements; `--on` gives it to a machine that
+ * did not have it. Either change is written to the machine's audit record.
+ * With neither flag it prints the current setting.
+ */
+export default class DedicatedMachinesAgentBrowser extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        on: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        off: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/agent-browser.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+/**
+ * `skrr machines dedicated agent-browser` — do the agents on this machine get a
+ * browser? (OSK-13809)
+ *
+ * A new Dedicated Runtime gives its agents a browser by default; a machine
+ * created before that decision keeps what it had. This is the one switch for
+ * both directions, per machine: `--off` takes it away and it stays away across
+ * restarts, image updates and replacements; `--on` gives it to a machine that
+ * did not have it. Either change is written to the machine's audit record.
+ * With neither flag it prints the current setting.
+ */
+class DedicatedMachinesAgentBrowser extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Show or change whether the agents on a Dedicated Runtime get a browser. On by default for new machines; --off turns it off for this machine and it stays off.';
+    static examples = [
+        '<%= config.bin %> machines dedicated agent-browser <lease-id>',
+        '<%= config.bin %> machines dedicated agent-browser <lease-id> --off',
+        '<%= config.bin %> machines dedicated agent-browser <lease-id> --on --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        on: core_1.Flags.boolean({
+            description: "Give this machine's agents a browser. Recorded in the machine's audit record.",
+            exclusive: ['off'],
+        }),
+        off: core_1.Flags.boolean({
+            description: "Take the browser away from this machine's agents. Stays off until you turn it on. Recorded in the machine's audit record.",
+            exclusive: ['on'],
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesAgentBrowser);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const scope = this.scopeFrom(flags);
+        const wantsChange = flags.on || flags.off;
+        const response = await this.callDedicated(() => wantsChange
+            ? (0, dedicated_machines_1.setDedicatedRuntimeAgentBrowser)(leaseId, Boolean(flags.on), scope)
+            : (0, dedicated_machines_1.getDedicatedRuntimeAgentBrowser)(leaseId, scope));
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Agent browser on ${response.leaseId || leaseId}: ${(0, dedicated_machines_1.describeDedicatedAgentBrowser)(response, leaseId)}`);
+        if (wantsChange && response.changed === false) {
+            this.log('  Already set that way; nothing changed.');
+        }
+        else if (wantsChange && response.effectiveOnNextReconnect && response.offered === null) {
+            // The line above already names the restart when a daemon is connected.
+            this.log(`  Applies when the machine's daemon next reconnects; \`skrr machines dedicated restart ${leaseId}\` makes that now.`);
+        }
+    }
+}
+exports.default = DedicatedMachinesAgentBrowser;

package/dist/commands/machines/dedicated/show.js

@@ -6,7 +6,7 @@ const daemon_installer_1 = require("../../../lib/daemon-installer");
 const dedicated_machines_1 = require("../../../lib/dedicated-machines");
 const harnesses_1 = require("../../../lib/harnesses");
 class DedicatedMachinesShow extends dedicated_lease_command_1.DedicatedLeaseCommand {
-    static description = 'Show one Dedicated Runtime lease: state, size, workspace, spend against the cap, health, deletion clock and the engines its daemon registered';
+    static description = 'Show one Dedicated Runtime lease: state, size, workspace, spend against the cap, health, deletion clock, whether its agents get a browser, and the engines its daemon registered';
     static examples = [
         '<%= config.bin %> machines dedicated show <lease-id>',
         '<%= config.bin %> machines dedicated show <lease-id> --json',
@@ -47,6 +47,17 @@ class DedicatedMachinesShow extends dedicated_lease_command_1.DedicatedLeaseComm
         // which is what `skrrd update --check` on the machine reports (OSK-12153).
         // Best-effort: an unreachable feed is said, never read as "none newer".
         const latestDaemonRelease = lease.health?.image ? await readLatestDaemonRelease() : null;
+        // Whether the agents on this machine get a browser (OSK-13809). Its own
+        // route, because the setting lives on the machine's allow-list, not the
+        // lease. Best-effort like the reads above, and an unreadable answer is
+        // printed as unknown, never as off.
+        let agentBrowser;
+        try {
+            agentBrowser = await (0, dedicated_machines_1.getDedicatedRuntimeAgentBrowser)(leaseId, this.scopeFrom(flags));
+        }
+        catch (err) {
+            agentBrowser = { error: err?.message || 'unreadable' };
+        }
         if (flags.json) {
             const engines = (0, dedicated_machines_1.dedicatedLeaseHarnesses)(lease, harnesses).map((harness) => ({
                 harnessId: harness._id,
@@ -57,11 +68,15 @@ class DedicatedMachinesShow extends dedicated_lease_command_1.DedicatedLeaseComm
             this.log(JSON.stringify({
                 ...response,
                 harnesses: engines,
+                agentBrowser,
                 ...(latestDaemonRelease ? { latestDaemonRelease } : {}),
             }, null, 2));
             return;
         }
-        for (const line of (0, dedicated_machines_1.describeDedicatedLease)(lease, harnesses, { latestDaemonRelease })) {
+        for (const line of (0, dedicated_machines_1.describeDedicatedLease)(lease, harnesses, {
+            latestDaemonRelease,
+            agentBrowser,
+        })) {
             this.log(line);
         }
     }

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-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/exec-runtime-binary.d.ts

@@ -86,7 +86,9 @@ export type RuntimeBinaryOutput = {
  * post-condition probes, where output is evidence rather than user-facing
  * command output.
  */
-export declare function execRuntimeBinaryCapture(args: string[]): Promise<RuntimeBinaryOutput>;
+export declare function execRuntimeBinaryCapture(args: string[], opts?: {
+    timeoutMs?: number;
+}): Promise<RuntimeBinaryOutput>;
 /**
  * Check an installed daemon's top-level help before forwarding a command that
  * was added after older daemon releases shipped. A false result is useful to

package/dist/lib/exec-runtime-binary.js

@@ -251,7 +251,7 @@ function execRuntimeBinary(args, opts = {}) {
  * post-condition probes, where output is evidence rather than user-facing
  * command output.
  */
-function execRuntimeBinaryCapture(args) {
+function execRuntimeBinaryCapture(args, opts = {}) {
     return new Promise((resolve, reject) => {
         const bin = findRuntimeBinary();
         if (!bin) {
@@ -279,8 +279,22 @@ function execRuntimeBinaryCapture(args) {
         child.stderr?.on('data', (chunk) => {
             stderr = append(stderr, chunk);
         });
-        child.on('error', reject);
+        // A probe is a read: past its bound it is abandoned (and the child
+        // stopped) rather than allowed to stall the command that asked.
+        const timer = opts.timeoutMs && opts.timeoutMs > 0
+            ? setTimeout(() => {
+                child.kill('SIGTERM');
+                reject(new Error('runtime-binary-probe-timeout'));
+            }, opts.timeoutMs)
+            : null;
+        child.on('error', (error) => {
+            if (timer)
+                clearTimeout(timer);
+            reject(error);
+        });
         child.on('exit', (code, signal) => {
+            if (timer)
+                clearTimeout(timer);
             resolve({
                 code: signal ? 128 + signalNumber(signal) : (code ?? 0),
                 stdout,