@skrr-ai/cli 0.1.88 → 0.1.90

package/dist/lib/dedicated-power.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDedicatedPowerPolicy = setDedicatedPowerPolicy;
+exports.describePolicyWords = describePolicyWords;
+exports.describePowerPolicy = describePowerPolicy;
+exports.getDedicatedPowerSummary = getDedicatedPowerSummary;
+exports.describePowerDecisionLines = describePowerDecisionLines;
+exports.describeLastAutoStopLines = describeLastAutoStopLines;
+exports.describeLastWakeDecisionLines = describeLastWakeDecisionLines;
+exports.describePowerSummary = describePowerSummary;
+exports.describePowerExplanation = describePowerExplanation;
+exports.describeBudget = describeBudget;
+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");
+function bodyOf(err) {
+    const raw = err?.body;
+    if (typeof raw !== 'string')
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 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.
+ */
+async function setDedicatedPowerPolicy(leaseId, request, scope = {}) {
+    try {
+        const response = await (0, api_fetch_1.apiFetch)((0, dedicated_machines_1.withDedicatedScope)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/power`, scope), { method: 'PUT', body: request });
+        return { ok: true, response };
+    }
+    catch (err) {
+        const body = bodyOf(err);
+        if (err?.status === 409 && body?.code === 'ON_DEMAND_INELIGIBLE') {
+            const reason = String(body.reason ?? '');
+            // The vocabulary is shared; the server's words win, the shared copy backs them up.
+            const copy = (0, data_provider_1.describeOnDemandIneligibility)(reason);
+            return {
+                ok: false,
+                refusal: {
+                    error: String(body.error ?? 'on_demand is not available for this machine yet.'),
+                    code: 'ON_DEMAND_INELIGIBLE',
+                    reason: reason,
+                    detail: String(body.detail ?? copy?.detail ?? ''),
+                    fix: String(body.fix ?? copy?.fix ?? ''),
+                },
+            };
+        }
+        throw err;
+    }
+}
+/**
+ * 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.
+ */
+function describePolicyWords(policy, idleAfterMinutes, autoStopMode) {
+    if (policy === 'on_demand') {
+        if (autoStopMode === 'on' || autoStopMode === 'canary') {
+            return `on_demand (stops after ${idleAfterMinutes} minutes idle)`;
+        }
+        // Unknown is neutral, never a claim in either direction.
+        return autoStopMode === 'off'
+            ? `on_demand (idle limit ${idleAfterMinutes} minutes; automatic stop is not turned on yet, so nothing stops it)`
+            : `on_demand (stops after ${idleAfterMinutes} minutes idle when automatic stop is on)`;
+    }
+    if (policy === 'manual')
+        return 'manual (stops and starts only when you do)';
+    return policy;
+}
+function describePowerPolicy(power, autoStopMode) {
+    const base = describePolicyWords(power.policy, power.idleAfterMinutes, autoStopMode);
+    return power.policyStored ? base : `${base} (default; never set)`;
+}
+/* ---- power show / explain (V5) ---------------------------------------------- */
+/** `GET /api/machines/dedicated/:leaseId/power` — the read-only power card. */
+function getDedicatedPowerSummary(leaseId, scope = {}) {
+    return (0, api_fetch_1.apiFetch)((0, dedicated_machines_1.withDedicatedScope)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/power`, scope));
+}
+/** The stay/stop/wake decision in words: the shared reason copy backs the server's detail. */
+function describePowerDecisionLines(decision) {
+    const copy = (0, data_provider_1.describePowerReason)(decision.reason);
+    const VERBS = { stay: 'Staying on', stop: 'Stopped', wake: 'Wake' };
+    const verb = VERBS[decision.question] ?? decision.question;
+    return {
+        // The headline is the human label only; the reason token lives in `--json` and `power explain`.
+        // With no shared copy and no server detail there is no sentence, so the token is the last resort.
+        headline: decision.detail || copy?.detail ? verb : `${verb}: ${decision.reason}`,
+        detail: decision.detail || copy?.detail || '',
+        fix: decision.fix ?? copy?.fix ?? 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.
+ */
+function describeLastAutoStopLines(last, decisionDetail = '', when = {}) {
+    if (!last)
+        return { lines: [], fix: null };
+    const lines = [];
+    const verdict = (0, data_provider_1.describeAutoStopVerdict)(last.verdict, { evidence: last.evidence });
+    const atText = last.at ? ` at ${(0, format_1.formatWhen)(last.at, when)}` : '';
+    lines.push(`Auto stop: ${verdict ? `${verdict.label} (${verdict.verdict})` : 'not checked yet'}${atText}`);
+    const checkpoint = (0, data_provider_1.describeMachineCheckpointOutcome)(last.checkpointOutcome, { action: 'stop' });
+    if (checkpoint && !decisionDetail.includes(checkpoint.sentence)) {
+        lines.push(`          ${checkpoint.sentence}`);
+    }
+    if (verdict && last.verdict !== 'clean') {
+        if (!decisionDetail.includes(verdict.detail))
+            lines.push(`          ${verdict.detail}`);
+        return { lines, fix: verdict.fix };
+    }
+    return { lines, fix: null };
+}
+function formatHours(hours) {
+    return `${Math.round(hours * 100) / 100}h`;
+}
+function formatUsage(usage) {
+    if (!usage.available)
+        return `unavailable (${usage.reason})`;
+    const cost = String(usage.currency).toLowerCase() === 'usd'
+        ? (0, dedicated_machines_1.formatUsdCents)(usage.costCents)
+        : `${usage.cost.toFixed(2)} ${String(usage.currency).toUpperCase()}`;
+    return `${formatHours(usage.hours)}, ${cost} in ${usage.month}${usage.openInterval ? ' (still running)' : ''}`;
+}
+function formatHolder(h, when) {
+    if (h.kind === 'unreadable') {
+        return `cannot see — staying on${h.detail ? ` (${h.detail})` : ''}`;
+    }
+    return [h.kind, h.ref, h.since ? `since ${(0, format_1.formatWhen)(h.since, when)}` : null]
+        .filter(Boolean)
+        .join(' · ');
+}
+/** The latest wake decision and who asked, as lines; empty when there is none. */
+function describeLastWakeDecisionLines(wake, when = {}) {
+    if (!wake)
+        return [];
+    // The sentence is the answer. The reason token and the transport ("http") are internals; who asked is
+    // named only when it is not the person reading this.
+    const asked = wake.source && wake.source !== 'person'
+        ? ` Asked by ${wake.source}${wake.sourceRef ? ` ${wake.sourceRef}` : ''}.`
+        : '';
+    const copy = (0, data_provider_1.describePowerReason)(wake.reason);
+    const sentence = wake.detail || copy?.detail || wake.reason;
+    const lines = [
+        `Wake:     ${sentence}${asked}${wake.at ? ` (${(0, format_1.formatWhen)(wake.at, when)})` : ''}`,
+    ];
+    if (wake.fix)
+        lines.push(`          ${wake.fix}`);
+    return lines;
+}
+/** The lines of `power show`. */
+function describePowerSummary(summary, when = {}) {
+    const { power } = summary;
+    const lines = [];
+    lines.push(`Dedicated Runtime ${summary.leaseId}`);
+    lines.push(`State:    ${summary.state}${summary.stateSince ? ` since ${(0, format_1.formatWhen)(summary.stateSince, when)}` : ''}`);
+    const policy = describePolicyWords(power.policy, power.idleAfterMinutes, summary.autoStopMode);
+    lines.push(`Policy:   ${policy}`);
+    if (power.keepAwakeUntil)
+        lines.push(`Keep awake until: ${(0, format_1.formatWhen)(power.keepAwakeUntil, when)}`);
+    if (power.budgetHoursPerMonth !== null)
+        lines.push(`Budget:   ${power.budgetHoursPerMonth} hours per month`);
+    if (summary.decision) {
+        const d = describePowerDecisionLines(summary.decision);
+        lines.push(`Decision: ${d.headline}`);
+        if (d.detail)
+            lines.push(`          ${d.detail}`);
+    }
+    else {
+        const none = (0, data_provider_1.describeNoPowerDecision)(summary);
+        if (none) {
+            lines.push(`Decision: ${none.headline}`);
+            lines.push(`          ${none.detail}`);
+        }
+        else {
+            lines.push('Decision: nothing to explain for this state');
+        }
+    }
+    lines.push(...describeLastAutoStopLines(summary.lastAutoStop, summary.decision?.detail, when).lines);
+    lines.push(...describeLastWakeDecisionLines(summary.lastWakeDecision, when));
+    if (summary.holders === null) {
+        lines.push('Holders:  not checked (the machine is not running)');
+    }
+    else if (summary.holders.length === 0) {
+        lines.push('Holders:  none — idle');
+    }
+    else {
+        lines.push('Holders:');
+        for (const h of summary.holders)
+            lines.push(`  - ${formatHolder(h, when)}`);
+    }
+    lines.push(`This month: ${formatUsage(summary.usage)}`);
+    lines.push(`Next expected wake: ${(summary.nextExpectedWake ? (0, format_1.formatWhen)(summary.nextExpectedWake, when) : null) ??
+        (summary.nextExpectedWakeUnavailable ? 'unavailable' : 'none scheduled')}`);
+    lines.push(`Last wake: ${summary.lastWake
+        ? `${summary.lastWake.at ? (0, format_1.formatWhen)(summary.lastWake.at, when) : 'unknown time'}${summary.lastWake.source ? ` (${summary.lastWake.source})` : ''}`
+        : 'none'}`);
+    return lines;
+}
+/** The lines of `power explain`; the fix is always last. */
+function describePowerExplanation(summary, when = {}) {
+    const lines = [];
+    if (!summary.decision) {
+        const none = (0, data_provider_1.describeNoPowerDecision)(summary);
+        lines.push(none ? `${none.headline}. ${none.detail}` : `Nothing to explain for ${summary.leaseId}.`);
+        lines.push(...describeLastWakeDecisionLines(summary.lastWakeDecision, when));
+        return lines;
+    }
+    const d = summary.decision;
+    const text = describePowerDecisionLines(d);
+    const wakeLines = describeLastWakeDecisionLines(summary.lastWakeDecision, when);
+    lines.push(`Question: ${d.question}`);
+    lines.push(`Gate:     ${d.gate}`);
+    lines.push(`Reason:   ${d.reason}`);
+    if (d.at)
+        lines.push(`At:       ${(0, format_1.formatWhen)(d.at, when)}`);
+    if (text.detail)
+        lines.push(`Detail:   ${text.detail}`);
+    const stop = describeLastAutoStopLines(summary.lastAutoStop, d.detail, when);
+    lines.push(...stop.lines);
+    lines.push(...wakeLines);
+    // A false stop's fix replaces nothing: the decision's own fix is still last-but-one.
+    if (text.fix && text.fix !== stop.fix)
+        lines.push(`Fix: ${text.fix}`);
+    if (stop.fix)
+        lines.push(`Fix: ${stop.fix}`);
+    return lines;
+}
+function describeBudget(power) {
+    return power.budgetHoursPerMonth == null
+        ? 'Monthly compute-hour budget: none.'
+        : `Monthly compute-hour budget: ${power.budgetHoursPerMonth} hours. At the budget, automatic starts are refused; a running machine is never stopped by it and you can still start it yourself.`;
+}

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,

package/dist/lib/format.d.ts

@@ -98,3 +98,16 @@ export declare function localTime(value: unknown): string;
  * rather than print an empty parenthesis.
  */
 export declare function localZone(at?: Date): string;
+export type WhenOptions = {
+    /** The reference instant; injectable so output is deterministic in tests. */
+    now?: Date;
+    /** IANA zone to render in; defaults to the reader's own. */
+    timeZone?: string;
+};
+/**
+ * A timestamp for a person: local time plus how far away it is, `07:38 (2h ago)`
+ * or `09:39 (in 1h 59m)`. The date is added only when it is not today in the
+ * rendered zone (`2026-10-07 22:10 (11h ago)`). Machine output (`--json`) keeps
+ * the raw ISO string; this is for text only. Unparseable input is returned as is.
+ */
+export declare function formatWhen(value: unknown, options?: WhenOptions): string;

package/dist/lib/format.js

@@ -9,6 +9,7 @@ exports.renderTable = renderTable;
 exports.localStamp = localStamp;
 exports.localTime = localTime;
 exports.localZone = localZone;
+exports.formatWhen = formatWhen;
 /**
  * Code points that occupy TWO terminal columns (Unicode East Asian Wide and
  * Fullwidth), plus the emoji blocks terminals render double-width.
@@ -259,3 +260,53 @@ function localZone(at = new Date()) {
     const abs = Math.abs(offset);
     return `UTC${sign}${`${Math.floor(abs / 60)}`.padStart(2, '0')}:${`${abs % 60}`.padStart(2, '0')}`;
 }
+function zonedParts(date, timeZone) {
+    const parts = new Intl.DateTimeFormat('en-CA', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hourCycle: 'h23',
+    }).formatToParts(date);
+    const out = {};
+    for (const p of parts)
+        out[p.type] = p.value;
+    return out;
+}
+function relativeSpan(ms) {
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 1)
+        return 'under a minute';
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return minutes % 60 ? `${hours}h ${minutes % 60}m` : `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return hours % 24 ? `${days}d ${hours % 24}h` : `${days}d`;
+}
+/**
+ * A timestamp for a person: local time plus how far away it is, `07:38 (2h ago)`
+ * or `09:39 (in 1h 59m)`. The date is added only when it is not today in the
+ * rendered zone (`2026-10-07 22:10 (11h ago)`). Machine output (`--json`) keeps
+ * the raw ISO string; this is for text only. Unparseable input is returned as is.
+ */
+function formatWhen(value, options = {}) {
+    if (value === null || value === undefined || value === '')
+        return '-';
+    const date = value instanceof Date ? value : new Date(typeof value === 'number' ? value : String(value));
+    if (Number.isNaN(date.getTime()))
+        return String(value);
+    const now = options.now ?? new Date();
+    const at = zonedParts(date, options.timeZone);
+    const ref = zonedParts(now, options.timeZone);
+    const sameDay = at.year === ref.year && at.month === ref.month && at.day === ref.day;
+    const clock = `${at.hour}:${at.minute}`;
+    const stamp = sameDay ? clock : `${at.year}-${at.month}-${at.day} ${clock}`;
+    const delta = date.getTime() - now.getTime();
+    const span = relativeSpan(Math.abs(delta));
+    const relative = span === 'under a minute' ? 'just now' : delta >= 0 ? `in ${span}` : `${span} ago`;
+    return `${stamp} (${relative})`;
+}

package/dist/lib/keychain.js

@@ -150,6 +150,9 @@ function setActiveProfile(profile) {
     _profileResolved = true;
     if (profile && profile.length > 0)
         _activeProfile = profile;
+    // The machineUuid the CLI sends (first-party harness broker) is per profile,
+    // exactly as the daemon's is (OSK-13845); both read the same persisted choice.
+    (0, auth_core_1.setMachineUuidProfile)(_activeProfile);
 }
 /**
  * Whether the profile has been chosen for this process.

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/computerWire.d.ts

@@ -33,6 +33,22 @@ export declare const COMPUTER_EVENTS: {
     readonly attach: "computer:attach";
     /** client → API: leave. */
     readonly detach: "computer:detach";
+    /**
+     * client → API: read the whole manifest again ON THE SAME ATTACHMENT, after
+     * a missed delta or a `stale_epoch` (OSK-13815). The ack carries what an
+     * attach's does — the attachment id (unchanged), the manifest and the
+     * operations — or a typed refusal; `not_found` means the attachment is gone
+     * and only then does the client attach afresh. Re-reading state must never
+     * change who the reader is: a control lease is bound to the attachment
+     * (`holderAttachmentId`), and a resync that detached and attached again
+     * orphaned the hold the person had just taken. Answered by the API, which
+     * renews the binding with the daemon exactly as its periodic re-check does
+     * (a repeated `daemon:computer:attach` with the same id), so it has no
+     * daemon mirror and needs no daemon capability. An API that predates it
+     * never answers; the client bounds the wait and falls back to attaching
+     * afresh.
+     */
+    readonly resync: "computer:resync";
     /** API → client: this attachment was detached, with the reason (revoked, stale generation, …). */
     readonly detached: "computer:detached";
     /** API → client: a whole manifest, or a revisioned delta. */
@@ -162,6 +178,22 @@ export declare const DAEMON_COMPUTER_EVENT_NAMES: readonly DaemonComputerEventNa
 export declare const DAEMON_COMPUTER_REPORT_EVENT_KEYS: readonly ["ack", "manifest", "data", "activity", "detached", "filesChanged", "diagnostics"];
 /** The API → client events; every other `computer:*` event flows client → API. */
 export declare const COMPUTER_SERVER_EVENT_KEYS: readonly ["detached", "manifest", "data", "activity", "filesChanged"];
+/**
+ * Client → API requests the API answers itself, with no `daemon:computer:*`
+ * mirror: every other client request is relayed to the daemon under the same
+ * key. `resync` renews the binding through the daemon's existing attach
+ * (OSK-13815).
+ */
+export declare const COMPUTER_API_ANSWERED_EVENT_KEYS: readonly ["resync"];
+/** How long the client waits for a `computer:resync` answer before attaching afresh (an API that predates it never answers). */
+export declare const COMPUTER_RESYNC_TIMEOUT_MS = 12000;
+/**
+ * How long a client holds a manifest delta that arrived AHEAD of its
+ * predecessor before reading the hole as a loss (OSK-13815). Deltas fan out
+ * through a relay of several replicas; a reorder is milliseconds, a loss is
+ * forever, and only a loss needs the whole manifest again.
+ */
+export declare const COMPUTER_MANIFEST_REORDER_WAIT_MS = 300;
 /**
  * One capability per wire addition, each withheld positively at dispatch: the
  * API never sends a computer event to a daemon that did not announce the
@@ -263,6 +295,42 @@ export declare const COMPUTER_CAPABILITIES: {
      * browser; nothing is proxied to it. Announced by the relay that serves it.
      */
     readonly declaredServices: "computer_declared_services_v1";
+    /**
+     * The page follows the controlling window (§6.2 "a stable viewport", §7.1,
+     * OSK-13808): a browser `viewport` input, sent only by the attachment that
+     * holds the browser's lease at the current epoch, sizes the streamed page
+     * to that window's content box (`COMPUTER_BROWSER_VIEWPORT_LIMITS`). Only
+     * while a person holds control: handing back — or the hold lapsing, being
+     * revoked or moving to the agent any other way — restores the browser's own
+     * viewport before the agent can act, so an agent never inherits a person's
+     * size. Watchers keep seeing the page at whatever size it is, scaled to
+     * fit. Announced only where the browser driver can override and restore
+     * the page's metrics; without it the window scales the fixed page, as
+     * before, and never sends the input.
+     */
+    readonly browserViewport: "computer_browser_viewport_v1";
+    /**
+     * A browser surface whose browser is still starting says so (OSK-13824): its
+     * descriptor carries `starting: { since }` from the moment its Chromium
+     * begins to launch until that launch ends (running, or failed), and the
+     * window shows "Starting the browser…" instead of subscribing into a
+     * refusal. A cold start on a fresh guest takes 25–30 s. A daemon announcing
+     * this states the ABSENCE of `starting` too: a browser surface without it
+     * is not starting. Without the announcement a client cannot tell, and falls
+     * back to reading a surface it saw open moments ago as starting.
+     */
+    readonly browserStarting: "computer_browser_starting_v1";
+    /**
+     * An agent actor on the machine's activity and control leases (OSK-13827)
+     * names the REAL agent: `agentId` is the agent's own id for tool-call and
+     * browser sessions too (v1 daemons put the SESSION id there for tool calls,
+     * so no reader could ever name them), and may carry `engine`, the harness
+     * the session runs on, so one agent's sessions on different engines can be
+     * told apart. A daemon announcing this states what it sends; the server
+     * withholds `engine` from every other daemon's actors, and a reader treats
+     * an actor without it as it always did.
+     */
+    readonly activityActorV2: "computer_activity_actor_v2";
 };
 export type ComputerCapabilityKey = keyof typeof COMPUTER_CAPABILITIES;
 export type ComputerCapability = (typeof COMPUTER_CAPABILITIES)[ComputerCapabilityKey];
@@ -271,14 +339,13 @@ export declare const COMPUTER_CAPABILITY_VALUES: [ComputerCapability, ...Compute
  * Every refusal and limit the computer protocol can answer with. Callers branch
  * on the code; a message beside it is free text and may change.
  */
-export declare const COMPUTER_REFUSAL_CODES: readonly ["human_control", "stale_epoch", "stale_generation", "file_changed", "capability_missing", "unauthorized", "control_denied", "not_holder", "attachment_limit", "observer_limit", "watch_limit", "grant_limit", "browser_limit", "rate_limited", "not_found", "surface_ended", "machine_unavailable", "daemon_unreachable", "timeout", "invalid_request", "consent_missing", "path_withheld", "too_large", "service_limit"];
+export declare const COMPUTER_REFUSAL_CODES: readonly ["human_control", "stale_epoch", "stale_generation", "file_changed", "capability_missing", "unauthorized", "control_denied", "not_holder", "attachment_limit", "observer_limit", "watch_limit", "grant_limit", "browser_limit", "rate_limited", "not_found", "surface_ended", "machine_unavailable", "daemon_unreachable", "relay_error", "timeout", "invalid_request", "consent_missing", "path_withheld", "too_large", "service_limit"];
 export type ComputerRefusalCode = (typeof COMPUTER_REFUSAL_CODES)[number];
 /**
- * Older spellings the daemon boundary accepts for one release (§5.2). After
- * that release this map is emptied, and nothing else names the old spelling.
+ * The code when it is a computer refusal, else `null`. There is one spelling
+ * per code: the browser's older spelling of `human_control` was accepted for
+ * one release and retired with the old browser events (§5.2, OSK-13509).
  */
-export declare const COMPUTER_LEGACY_REFUSAL_SPELLINGS: Readonly<Record<string, ComputerRefusalCode>>;
-/** The canonical code for a received spelling, or `null` when it is not a computer refusal. */
 export declare function normalizeComputerRefusalCode(code: unknown): ComputerRefusalCode | null;
 export declare const COMPUTER_ACTOR_KINDS: readonly ["agent", "human"];
 export type ComputerActorKind = (typeof COMPUTER_ACTOR_KINDS)[number];
@@ -291,13 +358,36 @@ export type ComputerActorKind = (typeof COMPUTER_ACTOR_KINDS)[number];
  */
 export declare const COMPUTER_ACTIVITY_ACTOR_KINDS: readonly ["agent", "human", "system"];
 export type ComputerActivityActorKind = (typeof COMPUTER_ACTIVITY_ACTOR_KINDS)[number];
+/**
+ * The session ids the PLATFORM's own routes run daemon tools under — the web
+ * Files surface (`computer-files:` on a personal machine, `dedicated-runtime:`
+ * on a Dedicated Runtime) and the owner's `skrr machines dedicated` commands.
+ * No agent and no model is behind such a session: the person who asked is
+ * known to the API (which audits it), not to the daemon. So an activity event
+ * produced under one names no agent (OSK-13790: a person's upload used to read
+ * "agent created …"). Built by `ComputerFileService.runPersonalMachineTool`
+ * and `DedicatedRuntimeMachineAccess.runDedicatedRuntimeTool`.
+ */
+export declare const COMPUTER_PLATFORM_ROUTE_SESSION_PREFIXES: readonly ["dedicated-runtime:", "computer-files:"];
+/** Whether a tool call's session is one of the platform's own routes, not an agent's. */
+export declare function isComputerPlatformRouteSession(sessionId: unknown): boolean;
 /** An agent session, as the wire names it. Same session = same `agentId` AND `sessionId`. */
 export interface ComputerWireAgentActor {
     kind: 'agent';
     agentId: string;
     sessionId: string;
     label: string;
+    /**
+     * The engine the session runs on (`claude-code`, `codex`, …), as the daemon
+     * names its backend. Present only from a daemon that announced
+     * `computer_activity_actor_v2` (`COMPUTER_CAPABILITIES.activityActorV2`).
+     * A display distinction between one agent's sessions, never an identity:
+     * `sameComputerActor` still compares the agent id and the session id.
+     */
+    engine?: string;
 }
+/** The longest `engine` the wire carries; a longer one is not an engine name. */
+export declare const COMPUTER_ACTOR_ENGINE_MAX_LENGTH = 64;
 export interface ComputerWireHumanActor {
     kind: 'human';
     userId: string;
@@ -420,7 +510,11 @@ export type ComputerSurfaceState = (typeof COMPUTER_SURFACE_STATES)[number];
  */
 export declare const COMPUTER_SURFACE_END_REASONS: readonly ["machine_stopped", "closed_by_owner", "closed", "process_exited", "daemon_restarted", "browser_crashed", "expired", "browser_reset"];
 export type ComputerSurfaceEndReason = (typeof COMPUTER_SURFACE_END_REASONS)[number];
-/** The browser's fixed logical viewport, whoever is looking (§6.2). */
+/**
+ * The browser's logical viewport whoever is looking (§6.2): what the agent
+ * always works at. A person holding control may size the page to their window
+ * (`computer_browser_viewport_v1`); handing back restores this.
+ */
 export declare const COMPUTER_BROWSER_VIEWPORT: Readonly<{
     width: 1280;
     height: 800;
@@ -492,8 +586,41 @@ export interface ComputerTerminalInfo {
     };
     caveats?: ComputerTerminalCaveat[];
 }
-/** Input a browser surface takes. `tab` needs `computer_browser_tabs_v1`. */
-export declare const COMPUTER_BROWSER_INPUT_TYPES: readonly ["pointer", "key", "text", "navigate", "history", "tab"];
+/**
+ * Input a browser surface takes. `tab` needs `computer_browser_tabs_v1`;
+ * `viewport` needs `computer_browser_viewport_v1`.
+ */
+export declare const COMPUTER_BROWSER_INPUT_TYPES: readonly ["pointer", "key", "text", "navigate", "history", "tab", "viewport"];
+/**
+ * What a `viewport` input may ask of the page (OSK-13808), in CSS pixels: the
+ * controlling window's content box, bounded so no window can make the page
+ * absurd for the agent that gets it back, and aspect-clamped (`minAspect` and
+ * `maxAspect` are width ÷ height) so a sliver of a window cannot either.
+ * Device pixel ratio is not part of it: the page keeps the browser's own, so a
+ * high-density screen changes no layout and no picture size.
+ */
+export declare const COMPUTER_BROWSER_VIEWPORT_LIMITS: Readonly<{
+    minWidth: 320;
+    maxWidth: 2560;
+    minHeight: 240;
+    maxHeight: 1600;
+    minAspect: 0.4;
+    maxAspect: 3.2;
+}>;
+/**
+ * The size a `viewport` input asks for, made legal: whole CSS pixels inside
+ * `COMPUTER_BROWSER_VIEWPORT_LIMITS`, its aspect inside the clamp. Total and
+ * idempotent: the window sends what this returns and the daemon applies what
+ * this returns, so both ends agree on the page a size produces. Null for a size
+ * with no area (a hidden or collapsed window asks for nothing).
+ */
+export declare function clampComputerBrowserViewport(size: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+} | null;
 /**
  * The client OS a browser `key` input comes from. A person's shortcuts are
  * mapped onto the Linux page's by the daemon: on `mac`, Command is Control,