@skrr-ai/cli 0.1.90 → 0.1.92

package/dist/commands/machines/dedicated/power/index.js

@@ -6,7 +6,7 @@ const core_1 = require("@oclif/core");
  * on its own. `set` is the standing policy; more verbs arrive with the power card.
  */
 class DedicatedMachinesPower extends core_1.Command {
-    static description = 'Power policy of a Dedicated Runtime — when it may stop and start on its own. Files are preserved across stops.\n\nSubcommands:\n  show        state, policy, holders, usage, next wake\n  explain     why it stayed on, stopped or woke, and the fix\n  set         always_on | on_demand | manual (+ --idle-after, --budget-hours)\n  keep-awake  --for <duration> | --until <iso> | --clear';
+    static description = 'Power policy of a Dedicated Runtime — when it may stop and start on its own. Files are preserved across stops.\n\nSubcommands:\n  show        state, policy, holders, usage, next wake\n  explain     why it stayed on, stopped or woke, and the fix\n  waiting     work waiting for the machine\n  set         always_on | on_demand | manual (+ --idle-after, --budget-hours/--no-budget)\n  keep-awake  --for <duration> | --until <iso> | --clear';
     static examples = [
         '<%= config.bin %> machines dedicated power set <lease-id> --policy manual',
         '<%= config.bin %> machines dedicated power set <lease-id> --policy on_demand --idle-after 60',
@@ -15,7 +15,8 @@ class DedicatedMachinesPower extends core_1.Command {
         this.log('skrr machines dedicated power commands:');
         this.log('  skrr machines dedicated power show      state, policy, holders, usage, next wake');
         this.log('  skrr machines dedicated power explain   why it stayed on, stopped or woke, and the fix');
-        this.log('  skrr machines dedicated power set   always_on | on_demand | manual (+ --idle-after)');
+        this.log('  skrr machines dedicated power waiting   work waiting for the machine');
+        this.log('  skrr machines dedicated power set   always_on | on_demand | manual (+ --idle-after, --budget-hours/--no-budget)');
         this.log('  skrr machines dedicated power keep-awake   --for <duration> | --until <iso> | --clear');
         this.log('');
         this.log('Every command takes a lease id (or `self` on the machine) and --json.');

package/dist/commands/machines/dedicated/power/waiting.d.ts

@@ -0,0 +1,13 @@
+import { DedicatedLeaseCommand } from '../../../../lib/dedicated-lease-command';
+/** `skrr machines dedicated power waiting` — what is waiting for this machine. Read-only. */
+export default class DedicatedMachinesPowerWaiting extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/power/waiting.js

@@ -0,0 +1,36 @@
+"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_power_1 = require("../../../../lib/dedicated-power");
+/** `skrr machines dedicated power waiting` — what is waiting for this machine. Read-only. */
+class DedicatedMachinesPowerWaiting extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'List work waiting for a Dedicated Runtime: parked trigger fires and runs, queued runs, and work just aimed at it. Derived from the schedulers own records. A source that cannot be read is said, not read as nothing waiting. Read-only.';
+    static examples = [
+        '<%= config.bin %> machines dedicated power waiting <lease-id>',
+        '<%= config.bin %> machines dedicated power waiting self --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesPowerWaiting);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const waiting = await this.callDedicated(() => (0, dedicated_power_1.getDedicatedWaitingWork)(leaseId, this.scopeFrom(flags)));
+        if (flags.json) {
+            this.log(JSON.stringify(waiting, null, 2));
+            return;
+        }
+        for (const line of (0, dedicated_power_1.describeWaitingWork)(waiting))
+            this.log(line);
+    }
+}
+exports.default = DedicatedMachinesPowerWaiting;

package/dist/commands/tasks/chat/send.d.ts

@@ -0,0 +1,44 @@
+import { BaseCommand } from '../../../base-command';
+export interface TaskChatSendInput {
+    text: string;
+    commandId?: string;
+    now?: boolean;
+}
+/**
+ * Build the `POST /api/tasks/:id/exchanges/messages` body.
+ *
+ * Every mutation on the task-chat surface requires an actor-scoped `commandId`;
+ * the server refuses to mint one (a server-minted id cannot make the caller's
+ * own retry idempotent). Without `--command-id` each invocation gets a FRESH id,
+ * because two sends of identical text are two intents (the unfenced-write rule
+ * in `idempotency.ts`). Pass the same `--command-id` to retry safely.
+ */
+export declare function buildTaskChatSendBody(input: TaskChatSendInput): {
+    immediate?: boolean | undefined;
+    commandId: string;
+    text: string;
+};
+/** One human line for a send result; never claims dispatch the server did not report. */
+export declare function describeSendResult(result: Record<string, unknown>): string;
+/**
+ * `skrr tasks chat send <task-id> --text "..."` — post a message into a Task's
+ * chat (the Task Multi-Turn Conversation surface).
+ *
+ * By default the message joins the current batch and the agent answers when the
+ * batch closes (several messages, one response). `--now` closes the batch and
+ * dispatches in the same request.
+ */
+export default class TasksChatSend extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        text: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        now: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'command-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/chat/send.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTaskChatSendBody = buildTaskChatSendBody;
+exports.describeSendResult = describeSendResult;
+const node_crypto_1 = require("node:crypto");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const task_extras_1 = require("../../../lib/task-extras");
+/** The server's `appendSchema` bounds on `commandId`. */
+const COMMAND_ID_MIN = 8;
+const COMMAND_ID_MAX = 128;
+/**
+ * Build the `POST /api/tasks/:id/exchanges/messages` body.
+ *
+ * Every mutation on the task-chat surface requires an actor-scoped `commandId`;
+ * the server refuses to mint one (a server-minted id cannot make the caller's
+ * own retry idempotent). Without `--command-id` each invocation gets a FRESH id,
+ * because two sends of identical text are two intents (the unfenced-write rule
+ * in `idempotency.ts`). Pass the same `--command-id` to retry safely.
+ */
+function buildTaskChatSendBody(input) {
+    const text = input.text?.trim() ? input.text : '';
+    if (!text)
+        throw new Error('A message needs non-empty text (--text).');
+    const commandId = input.commandId ?? `cli-${(0, node_crypto_1.randomUUID)()}`;
+    if (commandId.length < COMMAND_ID_MIN) {
+        throw new Error(`--command-id must be at least ${COMMAND_ID_MIN} characters.`);
+    }
+    if (commandId.length > COMMAND_ID_MAX) {
+        throw new Error(`--command-id must be at most ${COMMAND_ID_MAX} characters.`);
+    }
+    return {
+        commandId,
+        text,
+        ...(input.now ? { immediate: true } : {}),
+    };
+}
+/** One human line for a send result; never claims dispatch the server did not report. */
+function describeSendResult(result) {
+    const exchangeId = String(result.exchangeId ?? '?');
+    const replay = result.replay === true ? ' (replay of an earlier send)' : '';
+    if (result.alreadyClosed === true) {
+        return `Exchange ${exchangeId} was already closed${replay}.`;
+    }
+    if (result.materialized === false) {
+        return `Message recorded in exchange ${exchangeId}${replay}, but no run was started: ${String(result.reason ?? 'unknown reason')}.`;
+    }
+    if (result.materialized === true) {
+        const run = result.taskExecutionRunId ? ` as run ${String(result.taskExecutionRunId)}` : '';
+        return `Message sent in exchange ${exchangeId}${replay}; dispatched${run}.`;
+    }
+    const close = result.softCloseAt ? ` Batch closes at ${String(result.softCloseAt)}.` : '';
+    return `Message recorded in exchange ${exchangeId}${replay}; the batch is still collecting, not yet dispatched.${close} Use --now to dispatch immediately.`;
+}
+/**
+ * `skrr tasks chat send <task-id> --text "..."` — post a message into a Task's
+ * chat (the Task Multi-Turn Conversation surface).
+ *
+ * By default the message joins the current batch and the agent answers when the
+ * batch closes (several messages, one response). `--now` closes the batch and
+ * dispatches in the same request.
+ */
+class TasksChatSend extends base_command_1.BaseCommand {
+    static description = "Send a message into a task's chat";
+    static examples = [
+        '<%= config.bin %> tasks chat send task_abc123 --text "Also cover the retry path"',
+        '<%= config.bin %> tasks chat send OSK-42 --text "Go ahead" --now',
+        '<%= config.bin %> tasks chat send OSK-42 --text "Go ahead" --now --command-id my-retry-key-1',
+    ];
+    static args = {
+        id: core_1.Args.string({ ignoreStdin: true, description: 'Task ID or identifier', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        text: core_1.Flags.string({ description: 'Message text', required: true }),
+        now: core_1.Flags.boolean({
+            description: 'Close the batch and dispatch immediately instead of waiting for it to close',
+        }),
+        'command-id': core_1.Flags.string({
+            description: `Actor-scoped command id (${COMMAND_ID_MIN}-${COMMAND_ID_MAX} chars). Reuse it to retry safely; generated fresh when omitted`,
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksChatSend);
+        let body;
+        try {
+            body = buildTaskChatSendBody({
+                text: flags.text,
+                commandId: flags['command-id'],
+                now: flags.now,
+            });
+        }
+        catch (err) {
+            this.error(err.message, { exit: 2 });
+        }
+        const taskId = await this.resolveTaskReference(args.id);
+        let result;
+        try {
+            result = await task_extras_1.taskChatApi.sendExchangeMessage(taskId, body);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ commandId: body.commandId, ...result }, null, 2));
+            return;
+        }
+        this.log(describeSendResult(result));
+    }
+}
+exports.default = TasksChatSend;

package/dist/commands/tasks/start.d.ts

@@ -14,6 +14,16 @@ export default class TasksStart extends BaseCommand {
     };
     run(): Promise<void>;
 }
+/**
+ * The server's `TASK_WAITING_FOR_MACHINE` answer to a start, or null for any other
+ * error. The code rides the response body (the route echoes it); the API client may
+ * also lift it onto `err.code`.
+ */
+export declare function waitingForMachine(err: unknown): {
+    message?: string;
+    reason?: string;
+    retryable?: boolean;
+} | null;
 /**
  * What to run next, printed after a start (OSK-12128). A start used to print
  * two ids and stop, and the way to watch it was found by accident. Every

package/dist/commands/tasks/start.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitingForMachine = waitingForMachine;
 exports.startFollowUpLines = startFollowUpLines;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
@@ -94,6 +95,30 @@ class TasksStart extends base_command_1.BaseCommand {
             result = await data_provider_1.dataService.startTask(taskId, flags.skill ? { skillId: flags.skill } : undefined);
         }
         catch (err) {
+            // A stopped Dedicated machine is being started for this work. That is the
+            // wake WORKING, not a failure: the server re-drives the start by itself once
+            // the machine is assignable (OSK-14010), so report it and exit 0.
+            const waiting = waitingForMachine(err);
+            if (waiting) {
+                if (flags.json) {
+                    this.log(JSON.stringify({
+                        waiting: true,
+                        code: 'TASK_WAITING_FOR_MACHINE',
+                        taskId,
+                        task: { ...taskIdentity, id: taskId },
+                        ...(branch ? { branch } : {}),
+                        ...waiting,
+                    }, null, 2));
+                    return;
+                }
+                if (branch) {
+                    this.log(`${branch.created ? 'Created' : 'Checked out'} branch: ${branch.branch}`);
+                }
+                this.log(`Task ${taskIdentity.id} is waiting for the machine to start; the task will run by itself once it is ready.`);
+                if (waiting.message)
+                    this.log(waiting.message);
+                return;
+            }
             // Name the task in the failure. `skrr tasks start` is the command people
             // fan out — five concurrent starts share one stderr, and the server's
             // "Task already has an active run; start rejected" identifies none of
@@ -119,6 +144,40 @@ class TasksStart extends base_command_1.BaseCommand {
     }
 }
 exports.default = TasksStart;
+/**
+ * The server's `TASK_WAITING_FOR_MACHINE` answer to a start, or null for any other
+ * error. The code rides the response body (the route echoes it); the API client may
+ * also lift it onto `err.code`.
+ */
+function waitingForMachine(err) {
+    if (!err || typeof err !== 'object')
+        return null;
+    const e = err;
+    let body = {};
+    if (typeof e.body === 'string') {
+        try {
+            const parsed = JSON.parse(e.body);
+            if (parsed && typeof parsed === 'object')
+                body = parsed;
+        }
+        catch {
+            // not JSON: fall back to err.code
+        }
+    }
+    else if (e.body && typeof e.body === 'object') {
+        body = e.body;
+    }
+    if (body.code !== 'TASK_WAITING_FOR_MACHINE' && e.code !== 'TASK_WAITING_FOR_MACHINE') {
+        return null;
+    }
+    const text = [body.error, body.message].find((v) => typeof v === 'string');
+    const message = text || undefined;
+    return {
+        ...(message ? { message } : {}),
+        ...(typeof body.reason === 'string' ? { reason: body.reason } : {}),
+        ...(typeof body.retryable === 'boolean' ? { retryable: body.retryable } : {}),
+    };
+}
 /**
  * What to run next, printed after a start (OSK-12128). A start used to print
  * two ids and stop, and the way to watch it was found by accident. Every

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): {

package/dist/lib/dedicated-power.js

@@ -4,6 +4,11 @@ exports.setDedicatedPowerPolicy = setDedicatedPowerPolicy;
 exports.describePolicyWords = describePolicyWords;
 exports.describePowerPolicy = describePowerPolicy;
 exports.getDedicatedPowerSummary = getDedicatedPowerSummary;
+exports.getDedicatedWaitingWork = getDedicatedWaitingWork;
+exports.describeWaitingWork = describeWaitingWork;
+exports.describeLastWakeTiming = describeLastWakeTiming;
+exports.describeOnDemandAvailability = describeOnDemandAvailability;
+exports.describePrewarm = describePrewarm;
 exports.describePowerDecisionLines = describePowerDecisionLines;
 exports.describeLastAutoStopLines = describeLastAutoStopLines;
 exports.describeLastWakeDecisionLines = describeLastWakeDecisionLines;
@@ -83,6 +88,118 @@ function describePowerPolicy(power, autoStopMode) {
 function getDedicatedPowerSummary(leaseId, scope = {}) {
     return (0, api_fetch_1.apiFetch)((0, dedicated_machines_1.withDedicatedScope)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/power`, scope));
 }
+/** `GET /api/machines/dedicated/:leaseId/power/waiting` — work waiting for this machine. */
+function getDedicatedWaitingWork(leaseId, scope = {}) {
+    return (0, api_fetch_1.apiFetch)((0, dedicated_machines_1.withDedicatedScope)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/power/waiting`, scope));
+}
+const WAITING_SOURCE_LABELS = {
+    dispatch_intent: 'just dispatched',
+    parked_fire: 'parked trigger fire',
+    parked_run: 'parked run',
+    queued_run: 'queued run',
+    agent_queued_run: 'queued run (agent)',
+    expected_firing: 'expected firing',
+};
+/** The lines of `power waiting`. An unreadable source is said, never folded into "nothing waiting". */
+function describeWaitingWork(waiting, when = {}) {
+    const lines = [`Dedicated Runtime ${waiting.leaseId} (${waiting.state})`];
+    if (waiting.items.length === 0 && waiting.unreadable.length === 0) {
+        lines.push('Waiting work: none');
+    }
+    else {
+        lines.push(waiting.items.length === 0
+            ? 'Waiting work: none seen'
+            : `Waiting work: ${waiting.items.length} item${waiting.items.length === 1 ? '' : 's'}`);
+        for (const item of waiting.items) {
+            const label = WAITING_SOURCE_LABELS[item.source] ?? item.source;
+            lines.push(`  - ${label} ${item.ref}${item.since ? ` · since ${(0, format_1.formatWhen)(item.since, when)}` : ''}`);
+            if (item.detail)
+                lines.push(`    ${item.detail}`);
+        }
+    }
+    if (waiting.truncated.length > 0) {
+        lines.push(`More exists than is listed (${waiting.truncated.join(', ')}).`);
+    }
+    for (const u of waiting.unreadable) {
+        lines.push(`Cannot see ${u.source} (${u.reason}) — treat the list as incomplete.`);
+    }
+    const up = waiting.upcoming;
+    if (up) {
+        if (up.items.length > 0) {
+            lines.push(`Scheduled to fire: ${up.items.length}${up.truncated ? '+' : ''}`);
+            for (const f of up.items) {
+                lines.push(`  - ${f.source} ${f.title ?? f.ref}${f.at ? ` · ${(0, format_1.formatWhen)(f.at, when)}` : ''}`);
+            }
+        }
+        else if (up.unreadable.length === 0) {
+            lines.push('Scheduled to fire: none');
+        }
+        else {
+            lines.push('Scheduled to fire: none seen');
+        }
+        if (up.overdue > 0) {
+            lines.push(`${up.overdue} overdue firing${up.overdue === 1 ? '' : 's'} not yet fired.`);
+        }
+        for (const u of up.unreadable) {
+            lines.push(`Cannot see ${u.source} (${u.reason}) — scheduled firings may be missing.`);
+        }
+    }
+    if (waiting.state === 'stopped' && waiting.items.length > 0) {
+        lines.push('The machine is stopped. `skrr machines dedicated start <lease> --wait` starts it; work on an on_demand machine wakes it by itself.');
+    }
+    return lines;
+}
+const PHASE_ORDER = [
+    'start_requested',
+    'provider_start_accepted',
+    'instance_running',
+    'daemon_connected',
+    'first_heartbeat',
+    'assignable',
+];
+function formatMs(ms) {
+    return ms >= 1000 ? `${Math.round(ms / 100) / 10}s` : `${Math.round(ms)}ms`;
+}
+/** Last wake timing. A wake that never became assignable shows the phases it reached and no latency. */
+function describeLastWakeTiming(wake) {
+    if (!wake)
+        return [];
+    const known = Object.keys(wake.phases ?? {});
+    const names = [
+        ...PHASE_ORDER.filter((p) => known.includes(p)),
+        ...known.filter((p) => !PHASE_ORDER.includes(p)),
+    ].filter((p) => p !== 'start_requested');
+    const phases = names.map((p) => `${p} +${formatMs(wake.phases[p])}`).join(', ');
+    const total = wake.latencyMs === null || wake.latencyMs === undefined
+        ? 'not ready yet (no latency recorded)'
+        : `ready after ${formatMs(wake.latencyMs)}`;
+    return [`Wake timing: ${total}${phases ? ` — ${phases}` : ''}`];
+}
+/** on_demand availability, so a plan does not need a failed `power set` to find out. */
+function describeOnDemandAvailability(onDemand) {
+    if (!onDemand)
+        return [];
+    if (onDemand.eligible)
+        return ['on_demand: available'];
+    return [
+        `on_demand: not available (${onDemand.reason})`,
+        `          ${onDemand.detail}`,
+        `          Fix: ${onDemand.fix}`,
+    ];
+}
+/** Pre-warm lines: only a PAUSED pre-warm is in the summary, so silence here is not "pre-warm is on". */
+function describePrewarm(prewarm, when = {}) {
+    if (!prewarm?.paused)
+        return [];
+    const lines = [
+        `Pre-warm: paused${prewarm.since ? ` since ${(0, format_1.formatWhen)(prewarm.since, when)}` : ''} (${prewarm.idleStreak} early start${prewarm.idleStreak === 1 ? '' : 's'} in a row went unused)`,
+    ];
+    if (prewarm.decision?.detail)
+        lines.push(`          ${prewarm.decision.detail}`);
+    if (prewarm.decision?.fix)
+        lines.push(`          ${prewarm.decision.fix}`);
+    return lines;
+}
 /** 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);
@@ -205,6 +322,10 @@ function describePowerSummary(summary, when = {}) {
     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'}`);
+    lines.push(...describeLastWakeTiming(summary.lastWake));
+    lines.push(...describePrewarm(summary.prewarm, when));
+    if (power.policy !== 'on_demand')
+        lines.push(...describeOnDemandAvailability(summary.onDemand));
     return lines;
 }
 /** The lines of `power explain`; the fix is always last. */
@@ -229,6 +350,8 @@ function describePowerExplanation(summary, when = {}) {
     const stop = describeLastAutoStopLines(summary.lastAutoStop, d.detail, when);
     lines.push(...stop.lines);
     lines.push(...wakeLines);
+    lines.push(...describeLastWakeTiming(summary.lastWake));
+    lines.push(...describePrewarm(summary.prewarm, when));
     // 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}`);

package/dist/node_modules/@skrr-ai/data-provider/index.js

@@ -40560,7 +40560,7 @@ var ry = Object.freeze(T(T(T({}, Object.fromEntries(ey.map(function(e3) {
 }))), Object.fromEntries(ny.map(function(e3) {
   return [e3, "wake"];
 }))));
-var ay = { held_by_session: { detail: "An agent session or a person is using the machine, so it stays on.", fix: "It can be stopped once the session ends, or stop it yourself. Files are preserved; running processes are not." }, held_by_terminal: { detail: "A terminal or SSH connection is open or was used recently, so the machine stays on.", fix: "Close the terminal and it can stop when idle, or stop it yourself. Files are preserved; running processes are not." }, held_by_service: { detail: "A service you declared is running on the machine, so it stays on.", fix: "Stop the service, or stop the machine yourself if you do not need it. Files are preserved; running processes are not." }, held_by_pending_work: { detail: "Work is waiting for this machine, so it stays on.", fix: "It can stop once the waiting work has finished." }, keep_awake: { detail: "You asked to keep this machine awake, so it will not stop automatically for now.", fix: "Cancel keep-awake to let it stop when idle." }, policy_always_on: { detail: "This machine is set to always be on, so it does not stop automatically.", fix: "Change its power policy to on demand to let it stop when idle, or stop it yourself." }, activity_unreadable: { detail: "The machine activity could not be read, so it was left on to be safe. This does not mean it is idle.", fix: "Check that the machine is connected. It can stop once its activity can be read again, or stop it yourself." }, idle_auto_stop: { detail: $v.idle_auto_stop, fix: "Start it again when you need it." }, owner_stop: { detail: "Stopped by you. Your files are kept; running processes are not.", fix: "Start it again when you need it." }, billing_stop: { detail: "Stopped because the account is not in good billing standing. Your files are kept; running processes are not.", fix: "Resolve billing, then start the machine again." }, spend_cap_stop: { detail: "Stopped because the spend cap was reached. Your files are kept; running processes are not.", fix: "Raise the spend cap, then start the machine again." }, woken_by_schedule: { detail: "Started because a scheduled run was due.", fix: null }, woken_by_task: { detail: "Started because a task needed this machine.", fix: null }, woken_by_inbound: { detail: "Started because an incoming event needed this machine.", fix: null }, woken_by_person: { detail: "Started because you asked for this machine.", fix: null }, wake_refused_manual: { detail: "The machine was stopped by you and is set to manual, so it did not start for the waiting work.", fix: "Start it yourself, or change its power policy to on demand." }, wake_refused_spend_cap: { detail: "The machine did not start because the spend cap was reached.", fix: "Raise the spend cap, then start it again." }, wake_refused_entitlement: { detail: "The machine did not start because the plan no longer includes it.", fix: "Restore the plan, then start it again. Your files are preserved." }, wake_refused_provider_capacity: { detail: "The machine did not start because no capacity was available in its zone. It will be tried again.", fix: "Try again shortly or contact support." }, wake_refused_budget: { detail: "The machine did not start because its monthly compute-hour budget was reached.", fix: "Raise the budget, or start the machine manually." }, prewarm_paused_no_activity: { detail: "Starting this machine ahead of scheduled runs is off, because the last few early starts were not followed by any use. Scheduled work still starts it when it is due.", fix: "A start for real work, or a change to the power policy, turns early starts back on." } };
+var ay = { held_by_session: { detail: "An agent session or a person is using the machine, or did within the idle window, so it stays on.", fix: "It can be stopped once the session ends and the idle window passes, or stop it yourself. Files are preserved; running processes are not." }, held_by_terminal: { detail: "A terminal or SSH connection is open or was used recently, so the machine stays on.", fix: "Close the terminal and it can stop when idle, or stop it yourself. Files are preserved; running processes are not." }, held_by_service: { detail: "A service you declared is running on the machine, so it stays on.", fix: "Stop the service, or stop the machine yourself if you do not need it. Files are preserved; running processes are not." }, held_by_pending_work: { detail: "Work is waiting for this machine, so it stays on.", fix: "It can stop once the waiting work has finished." }, keep_awake: { detail: "You asked to keep this machine awake, so it will not stop automatically for now.", fix: "Cancel keep-awake to let it stop when idle." }, policy_always_on: { detail: "This machine is set to always be on, so it does not stop automatically.", fix: "Change its power policy to on demand to let it stop when idle, or stop it yourself." }, activity_unreadable: { detail: "The machine activity could not be read, so it was left on to be safe. This does not mean it is idle.", fix: "Check that the machine is connected. It can stop once its activity can be read again, or stop it yourself." }, idle_auto_stop: { detail: $v.idle_auto_stop, fix: "Start it again when you need it." }, owner_stop: { detail: "Stopped by you. Your files are kept; running processes are not.", fix: "Start it again when you need it." }, billing_stop: { detail: "Stopped because the account is not in good billing standing. Your files are kept; running processes are not.", fix: "Resolve billing, then start the machine again." }, spend_cap_stop: { detail: "Stopped because the spend cap was reached. Your files are kept; running processes are not.", fix: "Raise the spend cap, then start the machine again." }, woken_by_schedule: { detail: "Started because a scheduled run was due.", fix: null }, woken_by_task: { detail: "Started because a task needed this machine.", fix: null }, woken_by_inbound: { detail: "Started because an incoming event needed this machine.", fix: null }, woken_by_person: { detail: "Started because you asked for this machine.", fix: null }, wake_refused_manual: { detail: "The machine was stopped by you and is set to manual, so it did not start for the waiting work.", fix: "Start it yourself, or change its power policy to on demand." }, wake_refused_spend_cap: { detail: "The machine did not start because the spend cap was reached.", fix: "Raise the spend cap, then start it again." }, wake_refused_entitlement: { detail: "The machine did not start because the plan no longer includes it.", fix: "Restore the plan, then start it again. Your files are preserved." }, wake_refused_provider_capacity: { detail: "The machine did not start because no capacity was available in its zone. It will be tried again.", fix: "Try again shortly or contact support." }, wake_refused_budget: { detail: "The machine did not start because its monthly compute-hour budget was reached.", fix: "Raise the budget, or start the machine manually." }, prewarm_paused_no_activity: { detail: "Starting this machine ahead of scheduled runs is off, because the last few early starts were not followed by any use. Scheduled work still starts it when it is due.", fix: "A start for real work, or a change to the power policy, turns early starts back on." } };
 var iy = { busy_report_unavailable: { detail: "The machine has not told the platform when it is busy, so the platform cannot tell whether stopping it would interrupt work.", fix: "Start the machine and update its image (`skrr machines dedicated update-image <lease> --wait`), then try again. Until then it stays always_on." }, daemon_version_unknown: { detail: "The platform could not read which daemon version this machine runs.", fix: "Start the machine so its daemon reports in, then try again." }, daemon_too_old: { detail: "The daemon on this machine is older than the version that can report when it is busy.", fix: "Update the machine image (`skrr machines dedicated update-image <lease> --wait`), then try again. Files are preserved." }, declared_services: { detail: "This machine has declared services. A stopped service is not visible as busy, so an automatic stop could end it without warning.", fix: "Keep this machine always_on, or remove its declared services (`skrr machines dedicated service ls <lease>`)." }, services_unreadable: { detail: "The check that shows whether this machine has declared services cannot be completed yet, so the platform cannot show that an automatic stop is safe.", fix: "There is nothing you can do about this, and trying again will not change it. The machine stays always_on until the check ships; contact support if you need on_demand sooner." } };
 var sy = ["CONNECT_COUNTRY_REQUIRED", "CONNECT_COUNTRY_NOT_APPROVED", "CONNECT_COUNTRY_POLICY_NOT_CONFIGURED"];
 var cy = { payout_window_not_open: "Skipped: a payout was already made in this payout window.", below_minimum_payout: "Skipped: the available balance was below the minimum payout.", payouts_not_enabled: "Skipped: this Stripe account cannot receive payouts yet.", payout_request_refused: "Skipped: the balance changed while the payout was being reserved. It will be tried again.", payout_request_failed: "Failed: the payout could not be completed because of a problem on our side. Contact support if this keeps happening." };
@@ -45462,6 +45462,10 @@ var vM = Object.freeze({ __proto__: null, acceptAgentIntuition: function(e3, t2,
   return gf.get((function(e4) {
     return "".concat(nn, "/api/machines/dedicated/").concat(encodeURIComponent(e4), "/power");
   })(e3));
+}, getDedicatedRuntimeWaitingWork: function(e3) {
+  return gf.get((function(e4) {
+    return "".concat(nn, "/api/machines/dedicated/").concat(encodeURIComponent(e4), "/power/waiting");
+  })(e3));
 }, getDeviceTokens: function() {
   return gf.get(nr());
 }, getDirectChatWithFriend: function(e3) {