@skrr-ai/cli 0.1.86 → 0.1.88

package/bin/run.js

@@ -1,5 +1,16 @@
 #!/usr/bin/env node
 
+// Reuse V8's compiled code for this CLI's modules across runs. Every command
+// compiles oclif plus a 2.4MB vendored data-provider bundle before it can do
+// anything; with the cache that compile step is read back instead (Node >= 22.1;
+// a no-op on older Node and on Bun, and NODE_DISABLE_COMPILE_CACHE=1 turns it
+// off). The cache is keyed by file content, so a stale entry is never used.
+try {
+  require('node:module').enableCompileCache?.();
+} catch {
+  /* an optimisation must never be the reason a command cannot start */
+}
+
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 const { findAlternateCli, missingLocalCommandBuild } = require('./dev-fallback');

package/dist/base-command.js

@@ -512,6 +512,7 @@ class BaseCommand extends core_1.Command {
             const fresh = await (0, refresh_1.ensureFreshCliCredential)({
                 credential: this.resolvedCredential,
                 bareMode: this.bareMode,
+                reuseResolvedRead: true,
             });
             if (fresh.credential.token) {
                 this.resolvedCredential = fresh.credential;

package/dist/commands/agents/chat.d.ts

@@ -1,6 +1,6 @@
 import { dataService } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
-import { type AgenticStreamResult, type ReconciledTerminal } from '../../lib/agentic-stream';
+import { type AgenticStreamResult, type HandoverReading, type ReconciledTerminal } from '../../lib/agentic-stream';
 /**
  * Exit code for a run the USER stopped watching, by pressing Ctrl-C.
  *
@@ -73,6 +73,62 @@ export declare function interruptedDetachMessage(input: {
  * because a long tool call is silence, not a failure.
  */
 export declare function reconcileTerminalFromMessages(messages: ReadonlyArray<Record<string, unknown>>, responseMessageId?: string): ReconciledTerminal | null;
+/**
+ * Where a handed-over turn stands, read off its response message (OSK-13543).
+ *
+ * The server converges such a row to exactly one of two states, and only
+ * those two end the wait:
+ *
+ *   - REPAIRED — `error` cleared and `metadata.agentic.deliveryRepair` written,
+ *     by `sessionMessagePersister.repairDeliveryFailedMessage` on the machine's
+ *     completed turn-end. The repair record is required, not just `error:
+ *     false`: before the failure is saved a row can read `unfinished: false,
+ *     error: false` from a daemon flush that never writes `error`, and calling
+ *     that a success is the lie `recordHandedOverTurn` exists to prevent.
+ *   - SETTLED FAILED — still `error: true`, but no longer carrying the
+ *     hand-over reason (`lateDeliveryRepair.settleHandedOverFailure` moves it to
+ *     `worker_replaced_daemon_failed` with the machine's own reason).
+ *
+ * Everything else — still failed with the hand-over reason, not yet written,
+ * not found — is `pending`. Pure, so the mapping is testable without a socket.
+ */
+export declare function handoverStateFromMessages(messages: ReadonlyArray<Record<string, unknown>>, responseMessageId?: string): HandoverReading;
+/**
+ * How long `agents chat` waits for a handed-over turn by default (OSK-13543).
+ *
+ * Bounded above by the server's own hold: it quarantines the conversation for
+ * the worker job timeout plus a margin (30m + 5m, `conversationAdmissionClaim`)
+ * and after that stops treating the turn as possibly running, so waiting longer
+ * cannot observe anything the server would still act on. The default is well
+ * below that, because the cost of expiring is small and recoverable — the
+ * repair still lands on the record and `skrr messages list` shows it — while
+ * the cost of holding a terminal or a script is paid every minute. Ten minutes
+ * covers the repair observed in production (~90s after the failure) many times
+ * over and the long tail of a turn that was mid tool-call when the deploy hit.
+ */
+export declare const DEFAULT_HANDOVER_WAIT_SECONDS = 600;
+/** The server's hold for a handed-over turn: 30m job timeout + 5m lease margin. */
+export declare const MAX_HANDOVER_WAIT_SECONDS: number;
+/**
+ * What to say when Ctrl-C stops a hand-over wait. There is nothing to cancel
+ * through — the server relaying the turn is gone — so the honest statement is
+ * that the CLI stopped watching and the machine may still finish.
+ */
+export declare function handoverInterruptMessage(input: {
+    sessionId: string;
+    conversationId?: string | null;
+}): string;
+/**
+ * What one Ctrl-C does, by state. Exported so the decision is testable
+ * without delivering a signal:
+ *   - waiting on a handed-over turn → stop waiting at once (no cancel exists);
+ *   - first interrupt of a live run → request a cancel, wait the grace;
+ *   - any later interrupt → detach now.
+ */
+export declare function interruptAction(input: {
+    interrupts: number;
+    awaitingHandover: boolean;
+}): 'stop-handover-wait' | 'cancel' | 'detach';
 /**
  * How to look at a turn the CLI is no longer watching.
  *
@@ -168,6 +224,7 @@ export default class AgentsChat extends BaseCommand {
         quick: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         jsonl: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'repair-wait': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
         'approve-tools': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'permission-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'local-skill': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/agents/chat.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STREAM_LOST_EXIT_CODE = exports.DETACH_EXIT_CODE = void 0;
+exports.MAX_HANDOVER_WAIT_SECONDS = exports.DEFAULT_HANDOVER_WAIT_SECONDS = exports.STREAM_LOST_EXIT_CODE = exports.DETACH_EXIT_CODE = void 0;
 exports.streamedResultExitCode = streamedResultExitCode;
 exports.interruptedDetachMessage = interruptedDetachMessage;
 exports.reconcileTerminalFromMessages = reconcileTerminalFromMessages;
+exports.handoverStateFromMessages = handoverStateFromMessages;
+exports.handoverInterruptMessage = handoverInterruptMessage;
+exports.interruptAction = interruptAction;
 exports.inspectTurnCommand = inspectTurnCommand;
 exports.noOutputFailureMessage = noOutputFailureMessage;
 exports.noStreamJsonPayload = noStreamJsonPayload;
@@ -110,6 +113,9 @@ function reconcileTerminalFromMessages(messages, responseMessageId) {
             // The reason exists on the row; it simply never reached the surface. Say
             // it, rather than the transport error that masked it (OSK-7595).
             error: failure.reason ?? 'The run failed. No reason was recorded on the message.',
+            // Provisional, not final: the server rewrites this row from the
+            // machine's own turn-end (OSK-13543).
+            ...(agenticErrorSubtype(row) === agentic_stream_1.DAEMON_HANDOVER_REASON ? { handedOver: true } : {}),
         };
     }
     const text = typeof row.text === 'string' ? row.text : '';
@@ -120,6 +126,101 @@ function reconcileTerminalFromMessages(messages, responseMessageId) {
         return { status: 'completed', text };
     return null;
 }
+function agenticRecord(row) {
+    const metadata = row.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return null;
+    const agentic = metadata.agentic;
+    return agentic && typeof agentic === 'object' ? agentic : null;
+}
+function agenticErrorSubtype(row) {
+    const subtype = agenticRecord(row)?.errorSubtype;
+    return typeof subtype === 'string' ? subtype : undefined;
+}
+/**
+ * Where a handed-over turn stands, read off its response message (OSK-13543).
+ *
+ * The server converges such a row to exactly one of two states, and only
+ * those two end the wait:
+ *
+ *   - REPAIRED — `error` cleared and `metadata.agentic.deliveryRepair` written,
+ *     by `sessionMessagePersister.repairDeliveryFailedMessage` on the machine's
+ *     completed turn-end. The repair record is required, not just `error:
+ *     false`: before the failure is saved a row can read `unfinished: false,
+ *     error: false` from a daemon flush that never writes `error`, and calling
+ *     that a success is the lie `recordHandedOverTurn` exists to prevent.
+ *   - SETTLED FAILED — still `error: true`, but no longer carrying the
+ *     hand-over reason (`lateDeliveryRepair.settleHandedOverFailure` moves it to
+ *     `worker_replaced_daemon_failed` with the machine's own reason).
+ *
+ * Everything else — still failed with the hand-over reason, not yet written,
+ * not found — is `pending`. Pure, so the mapping is testable without a socket.
+ */
+function handoverStateFromMessages(messages, responseMessageId) {
+    const row = (responseMessageId && messages.find((m) => m?.messageId === responseMessageId)) ||
+        (!responseMessageId && [...messages].reverse().find((m) => m && m.isCreatedByUser === false));
+    if (!row)
+        return { state: 'pending' };
+    const failure = (0, data_provider_1.resolveMessageFailure)(row);
+    if (failure) {
+        if (agenticErrorSubtype(row) === agentic_stream_1.DAEMON_HANDOVER_REASON)
+            return { state: 'pending' };
+        return {
+            state: 'failed',
+            error: failure.reason ?? 'The run failed. No reason was recorded on the message.',
+            ...(failure.answer ? { text: failure.answer } : {}),
+        };
+    }
+    const repair = agenticRecord(row)?.deliveryRepair;
+    if (!repair || typeof repair !== 'object')
+        return { state: 'pending' };
+    // JSON over the wire makes this an ISO string; anything else is not shown.
+    const repairedAt = typeof repair.repairedAt === 'string' ? repair.repairedAt : undefined;
+    return {
+        state: 'repaired',
+        text: typeof row.text === 'string' ? row.text : '',
+        ...(repairedAt ? { repairedAt } : {}),
+    };
+}
+/**
+ * How long `agents chat` waits for a handed-over turn by default (OSK-13543).
+ *
+ * Bounded above by the server's own hold: it quarantines the conversation for
+ * the worker job timeout plus a margin (30m + 5m, `conversationAdmissionClaim`)
+ * and after that stops treating the turn as possibly running, so waiting longer
+ * cannot observe anything the server would still act on. The default is well
+ * below that, because the cost of expiring is small and recoverable — the
+ * repair still lands on the record and `skrr messages list` shows it — while
+ * the cost of holding a terminal or a script is paid every minute. Ten minutes
+ * covers the repair observed in production (~90s after the failure) many times
+ * over and the long tail of a turn that was mid tool-call when the deploy hit.
+ */
+exports.DEFAULT_HANDOVER_WAIT_SECONDS = 600;
+/** The server's hold for a handed-over turn: 30m job timeout + 5m lease margin. */
+exports.MAX_HANDOVER_WAIT_SECONDS = 35 * 60;
+/**
+ * What to say when Ctrl-C stops a hand-over wait. There is nothing to cancel
+ * through — the server relaying the turn is gone — so the honest statement is
+ * that the CLI stopped watching and the machine may still finish.
+ */
+function handoverInterruptMessage(input) {
+    return (`Stopped waiting for run ${input.sessionId}. A platform update had restarted the server ` +
+        'relaying it, and your machine MAY STILL BE WORKING on it: if it finishes, its reply is ' +
+        'saved to the conversation. Nothing was cancelled. ' +
+        `Check with: ${inspectTurnCommand(input.conversationId)}`);
+}
+/**
+ * What one Ctrl-C does, by state. Exported so the decision is testable
+ * without delivering a signal:
+ *   - waiting on a handed-over turn → stop waiting at once (no cancel exists);
+ *   - first interrupt of a live run → request a cancel, wait the grace;
+ *   - any later interrupt → detach now.
+ */
+function interruptAction(input) {
+    if (input.awaitingHandover)
+        return 'stop-handover-wait';
+    return input.interrupts === 1 ? 'cancel' : 'detach';
+}
 /**
  * How to look at a turn the CLI is no longer watching.
  *
@@ -158,6 +259,9 @@ function noStreamJsonPayload(input) {
         conversationId,
         responseMessageId: result.responseMessageId,
         status: result.status,
+        // The run first failed as handed over and the machine's reply was then
+        // repaired onto the record (OSK-13543).
+        ...(result.repaired ? { repaired: true } : {}),
         response: result.text,
         // The model a local harness reported running (OSK-12111). Absent on a
         // cloud turn and on a harness that reports none.
@@ -279,11 +383,30 @@ class AgentsChat extends base_command_1.BaseCommand {
                 'conversation; `message` says why. A `permission.resolved` says ' +
                 'how a local harness permission request was decided: `decidedBy` in words, and ' +
                 '`basis` — `person` (with `surface`), `mode` (with `mode`), `policy` or ' +
-                '`session-grant` — beside the wire `by`.',
+                '`session-grant` — beside the wire `by`. When a platform update restarts the server ' +
+                'relaying a turn your machine is still running, the run does not end at that failure: ' +
+                '`run.handed_over` (`code: "AGENT_WORKER_REPLACED"`, `reason: ' +
+                '"worker_replaced_daemon_running"`, `waitMs`, `deadlineAt`) says the CLI is waiting, ' +
+                'then exactly one terminal event follows — `run.completed` with `repaired: true` and ' +
+                '`result` (then `run.result` with `status: "completed"`, `repaired: true`, exit 0) when ' +
+                'the machine finished; `run.failed` with `handover.outcome: "machine_failed"` and the ' +
+                'machine\'s reason when it did not; or `run.failed` with `handover.outcome: "expired"` ' +
+                'and the original failure when --repair-wait ran out (exit 1 for both). Ctrl-C during ' +
+                'the wait emits `run.detached` with `handedOver: true` and exits 130.',
         }),
         json: core_1.Flags.boolean({
             description: 'Emit the final one-shot response as JSON (use with --no-stream)',
         }),
+        'repair-wait': core_1.Flags.integer({
+            description: 'Seconds to keep waiting when a platform update restarts the server relaying a turn ' +
+                'your machine is still running. The server repairs the reply onto the conversation ' +
+                'when the machine finishes, and the CLI prints it and exits 0; if the wait runs out ' +
+                'the original failure is reported. 0 ends at the failure immediately. At most the ' +
+                `server's own hold for such a turn (${exports.MAX_HANDOVER_WAIT_SECONDS}s).`,
+            default: exports.DEFAULT_HANDOVER_WAIT_SECONDS,
+            min: 0,
+            max: exports.MAX_HANDOVER_WAIT_SECONDS,
+        }),
         'approve-tools': core_1.Flags.boolean({
             description: 'Allow this turn to use permission-gated tools. In a terminal it asks per call; ' +
                 'with no terminal the flag itself is the approval for this turn, and each one is ' +
@@ -409,6 +532,21 @@ class AgentsChat extends base_command_1.BaseCommand {
         if (flags.conversation && flags['thread-root']) {
             this.error('--conversation and --thread-root are mutually exclusive.', { exit: 2 });
         }
+        // The agent read that picks the turn's default workspace depends on nothing
+        // below, so it starts now and runs beside the `--thread-root`, `--task` and
+        // `--local-skill` reads instead of after them (each is a full round trip).
+        // Only the LOOKUP starts here: the default is committed just before the
+        // turn, so those reads still go out without a workspace header, as before.
+        // `--quick` never consulted it. Never rejects.
+        //
+        // OSK-13599 — and a server already observed to choose the agent's home
+        // workspace itself is not asked at all: that read existed only to pick the
+        // header, and it is a full round trip before every turn. Only the SERVER's
+        // capability is remembered, never the agent's workspace (agents move).
+        const serverChoosesWorkspace = !flags.quick && (0, agent_home_workspace_1.serverAppliesAgentHomeDefault)(this.config?.cacheDir, this.cliConfig.baseURL);
+        const homeWorkspace = flags.quick || serverChoosesWorkspace
+            ? null
+            : (0, agent_home_workspace_1.lookupAgentHomeWorkspaceDefault)(args.agentId, (agentId) => data_provider_1.dataService.getAgentById({ agent_id: agentId }));
         let threadConversationId = flags.conversation;
         if (flags['thread-root']) {
             try {
@@ -522,7 +660,7 @@ class AgentsChat extends base_command_1.BaseCommand {
         const prompt = localSkills
             ? (0, local_skills_1.withSkillInvocations)(flags.prompt, localSkills.refs)
             : flags.prompt;
-        await (0, agent_home_workspace_1.applyAgentHomeWorkspaceDefault)(args.agentId, (agentId) => data_provider_1.dataService.getAgentById({ agent_id: agentId }));
+        (0, agent_home_workspace_1.commitAgentHomeWorkspaceDefault)(await homeWorkspace);
         let started;
         try {
             started = await data_provider_1.dataService.startAgenticChat({
@@ -547,6 +685,18 @@ class AgentsChat extends base_command_1.BaseCommand {
             // model is not supported."). The reader had to guess (OSK-4897).
             this.handleApiError(err);
         }
+        // OSK-13599 — the acceptance names the workspace the turn runs in. Adopt it
+        // for the rest of this turn (the stream's header, the message reads that
+        // reconcile its end, envelope replay) exactly as the pre-flight read's
+        // answer used to be adopted; a workspace the caller chose still wins, and
+        // an autonomous process still never takes one. It also tells us whether
+        // this server chooses the workspace itself, for the next turn.
+        const workspaceDefault = (0, agent_home_workspace_1.recordAgentHomeDefaultObservation)(this.config?.cacheDir, this.cliConfig.baseURL, started);
+        if (serverChoosesWorkspace && workspaceDefault === 'unsupported') {
+            this.warn('This server no longer chooses the agent’s home workspace, so this turn ran without ' +
+                'one. The next turn will select it again; pass --workspace to choose one now.');
+        }
+        (0, agent_home_workspace_1.commitAgentHomeWorkspaceDefault)(typeof started.workspaceId === 'string' && started.workspaceId ? started.workspaceId : null);
         if (!started.sessionId) {
             this.error('Agentic chat was accepted without a session ID; cannot attach the stream.', {
                 exit: 1,
@@ -564,6 +714,14 @@ class AgentsChat extends base_command_1.BaseCommand {
                 conversationId: started.conversationId,
                 ...(flags['thread-root'] ? { threadRootMessageId: flags['thread-root'] } : {}),
                 responseMessageId: started.responseMessageId,
+                // OSK-13599 — where the turn runs and who chose it, when the server
+                // says (`request` | `agent_home`); absent against an older server.
+                ...(workspaceDefault === 'supported'
+                    ? {
+                        workspaceId: started.workspaceId ?? null,
+                        workspaceSource: started.workspaceSource ?? null,
+                    }
+                    : {}),
                 agentId: args.agentId,
                 url: (0, web_url_1.agentUrlFrom)(this.cliConfig.baseURL, { id: args.agentId }),
             });
@@ -593,6 +751,21 @@ class AgentsChat extends base_command_1.BaseCommand {
                 return reconcileTerminalFromMessages(messages, started.responseMessageId);
             }
             : undefined;
+        // OSK-13543 — a turn handed over on a deploy is waited out against the same
+        // record. Without a conversation there is no record to read, so no wait.
+        const awaitHandover = conversationId
+            ? {
+                read: async () => {
+                    const messages = (await data_provider_1.dataService.getMessagesByConvoId(conversationId));
+                    if (!Array.isArray(messages))
+                        return null;
+                    return handoverStateFromMessages(messages, started.responseMessageId);
+                },
+                responseMessageId: started.responseMessageId,
+                conversationId,
+                maxWaitMs: (flags['repair-wait'] ?? exports.DEFAULT_HANDOVER_WAIT_SECONDS) * 1000,
+            }
+            : undefined;
         const client = new agentic_stream_1.AgenticStreamClient({
             baseURL: this.cliConfig.baseURL,
             token: this.resolvedCredential.token,
@@ -602,6 +775,7 @@ class AgentsChat extends base_command_1.BaseCommand {
             quiet,
             approveTools: flags['approve-tools'],
             reconcileTerminal,
+            awaitHandover,
             replayEnvelopes: (from) => (0, api_fetch_1.apiFetch)(`/api/agentic/sessions/${encodeURIComponent(started.sessionId)}/envelopes?from=${from}&limit=500`, { credential: this.resolvedCredential, signal: AbortSignal.timeout(5000) }),
         });
         // OSK-2938 — Ctrl-C must be bounded, visible, and honest about what it
@@ -636,7 +810,35 @@ class AgentsChat extends base_command_1.BaseCommand {
         let graceTimer = null;
         const onInterrupt = () => {
             interrupts += 1;
-            if (interrupts === 1) {
+            const action = interruptAction({ interrupts, awaitingHandover: client.awaitingHandover() });
+            if (action === 'stop-handover-wait') {
+                // Nothing to cancel and nothing to grace-wait for: stop at once.
+                if (!forcedDetachAnnounced) {
+                    forcedDetachAnnounced = true;
+                    const message = handoverInterruptMessage({
+                        sessionId: started.sessionId,
+                        conversationId: started.conversationId,
+                    });
+                    if (flags.jsonl) {
+                        (0, node_fs_1.writeSync)(process.stdout.fd, `${JSON.stringify({
+                            type: 'run.detached',
+                            sessionId: started.sessionId,
+                            conversationId: started.conversationId,
+                            interrupted: true,
+                            handedOver: true,
+                            message,
+                        })}\n`);
+                    }
+                    else {
+                        (0, node_fs_1.writeSync)(process.stderr.fd, `\n${message}\n`);
+                    }
+                    process.exitCode = exports.DETACH_EXIT_CODE;
+                }
+                client.close();
+                detach?.();
+                return;
+            }
+            if (action === 'cancel') {
                 client.cancel();
                 if (!flags.jsonl) {
                     this.log(`\nCancelling run ${started.sessionId}… (waiting up to ${CANCEL_GRACE_MS / 1000}s; ` +

package/dist/commands/computer/index.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+/**
+ * `skrr computer allow|deny|status` — the machine-local consent for the
+ * computer's new surfaces (§18/D11): the file surface and a person's own
+ * browser windows. Off by default; the daemon announces the answer as
+ * capabilities so the shell can say "this machine has not allowed the
+ * computer" instead of failing later.
+ */
+export default class Computer extends Command {
+    static description: string;
+    static args: {
+        action: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/computer/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const computer_consent_1 = require("../../lib/computer-consent");
+/**
+ * `skrr computer allow|deny|status` — the machine-local consent for the
+ * computer's new surfaces (§18/D11): the file surface and a person's own
+ * browser windows. Off by default; the daemon announces the answer as
+ * capabilities so the shell can say "this machine has not allowed the
+ * computer" instead of failing later.
+ */
+class Computer extends core_1.Command {
+    static description = 'Allow, deny, or show whether the computer may reach this machine — ' +
+        'its file surface and your own browser windows (off by default)';
+    static args = {
+        action: core_1.Args.string({
+            description: 'allow, deny, or status',
+            required: true,
+            options: ['allow', 'deny', 'status'],
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    static examples = [
+        '<%= config.bin %> computer status',
+        '<%= config.bin %> computer allow',
+        '<%= config.bin %> computer deny',
+        '<%= config.bin %> computer status --json',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Computer);
+        await (0, computer_consent_1.forwardComputerConsent)(this, [args.action, ...(flags.json ? ['--json'] : [])]);
+    }
+}
+exports.default = Computer;

package/dist/commands/labels/create.d.ts

@@ -3,6 +3,7 @@ export default class LabelsCreate extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'allow-duplicate-name': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         color: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/labels/create.js

@@ -30,6 +30,7 @@ class LabelsCreate extends base_command_1.BaseCommand {
         'group-exclusive': core_1.Flags.boolean({
             description: 'Make this label an exclusive group: at most one of ITS children may be attached to an entity at a time. Attaching a second child auto-detaches the first.',
         }),
+        ...label_scope_1.allowDuplicateNameFlags,
     };
     async run() {
         this.requireAuth();
@@ -58,6 +59,7 @@ class LabelsCreate extends base_command_1.BaseCommand {
                 ...(applicableTo ? { applicableTo } : {}),
                 ...(flags.parent ? { parentId: flags.parent } : {}),
                 ...(flags['group-exclusive'] ? { groupExclusive: true } : {}),
+                ...(flags['allow-duplicate-name'] ? { allowDuplicateName: true } : {}),
             });
         }
         catch (err) {

package/dist/commands/labels/restore.d.ts

@@ -6,6 +6,7 @@ export default class LabelsRestore extends BaseCommand {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        'allow-duplicate-name': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/labels/restore.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
+const label_scope_1 = require("../../lib/label-scope");
 class LabelsRestore extends base_command_1.BaseCommand {
     static description = 'Restore an archived label';
     static examples = [
@@ -14,16 +15,18 @@ class LabelsRestore extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        ...label_scope_1.allowDuplicateNameFlags,
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(LabelsRestore);
         // A live label with the same name may have been created while this one was
-        // archived; the server answers 409 `duplicate_name` in that case, which
-        // `handleApiError` surfaces verbatim.
+        // archived; the server answers 409 `duplicate_name` (same scope) or
+        // `duplicate_name_other_scope` in that case, which `handleApiError`
+        // surfaces verbatim.
         let result;
         try {
-            result = await data_provider_1.dataService.restoreLabel(args.id);
+            result = await data_provider_1.dataService.restoreLabel(args.id, flags['allow-duplicate-name'] ? { allowDuplicateName: true } : {});
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/labels/update.d.ts

@@ -6,6 +6,7 @@ export default class LabelsUpdate extends BaseCommand {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        'allow-duplicate-name': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         color: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/labels/update.js

@@ -36,6 +36,7 @@ class LabelsUpdate extends base_command_1.BaseCommand {
         'expected-version': core_1.Flags.integer({
             description: 'Optimistic-concurrency guard — fails with 409 if the label changed since you read it',
         }),
+        ...label_scope_1.allowDuplicateNameFlags,
     };
     async run() {
         this.requireAuth();
@@ -78,6 +79,7 @@ class LabelsUpdate extends base_command_1.BaseCommand {
                 ...(flags['expected-version'] !== undefined
                     ? { expectedVersion: flags['expected-version'] }
                     : {}),
+                ...(flags['allow-duplicate-name'] ? { allowDuplicateName: true } : {}),
             });
         }
         catch (err) {

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

@@ -0,0 +1,15 @@
+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
+ * describes the fleet, not the caller.
+ */
+export default class MachinesComputerAdoption extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+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
+ * 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 examples = [
+        '<%= config.bin %> machines computer-adoption',
+        '<%= config.bin %> machines computer-adoption --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(MachinesComputerAdoption);
+        const read = await (0, computer_adoption_1.getComputerAdoption)();
+        if (flags.json) {
+            this.log(JSON.stringify(read, null, 2));
+            return;
+        }
+        for (const line of (0, computer_adoption_1.computerAdoptionLines)(read))
+            this.log(line);
+    }
+}
+exports.default = MachinesComputerAdoption;

package/dist/commands/machines/dedicated/archive.d.ts

@@ -0,0 +1,26 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated archive` — download a folder from the machine as a
+ * tar file.
+ *
+ * The machine builds one staged archive of the folder (prepare), the CLI reads
+ * it in chunks (read) and frees it (release — always, including on a failed or
+ * cancelled download). The local file is written beside its destination and
+ * renamed into place, the same discipline `cp` keeps, so a cancelled download
+ * never leaves a partial `<name>.tar` — only the machine's staged copy, which
+ * release then removes.
+ */
+export default class DedicatedMachinesArchive extends DedicatedLeaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        destination: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}