@skrr-ai/cli 0.1.93 → 0.1.95

package/dist/commands/code/update.js

@@ -1,242 +1,163 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const auth_core_1 = require("@skrr-ai/auth-core");
-const base_command_1 = require("../../base-command");
-const cli_installers_1 = require("../../lib/cli-installers");
-const daemon_target_1 = require("../../lib/daemon-target");
-const first_party_harness_1 = require("../../lib/first-party-harness");
-/**
- * `skrr code update` — pull the engine's signed release down through the daemon.
- *
- * ── Why this command exists ────────────────────────────────────────────────
- *
- * The update verb has been API-exposed and daemon-implemented since OSK-10096 —
- * `POST /api/daemons/:id/cli-installers/:provider/update` re-fetches the signed
- * manifest and installs whatever the channel points at. But the only CLI that
- * reached it was `skrr harnesses install <provider> --update`: a flag on a
- * command a `code` user has no reason to read. On stable that left no
- * discoverable path at all — `code install` answered "Already installed." with
- * no next step, and the channel moving past the installed build was invisible
- * from the surface that owns the engine (OSK-10650).
- *
- * So this adds a SURFACE and no mechanism. Same route `harnesses install
- * --update` posts, same inventory pre-check, same 504 recovery — one update
- * path, spelled where the engine's users look.
- */
-class CodeUpdate extends base_command_1.BaseCommand {
-    static description = `Update the ${auth_core_1.FIRST_PARTY_HARNESS.displayName} engine on this machine, through the daemon`;
+const first_party_harness_update_1 = require("../../lib/first-party-harness-update");
+const first_party_harness_startup_update_1 = require("../../lib/first-party-harness-startup-update");
+/** The default target is this computer; an explicit daemon keeps the remote API path. */
+class CodeUpdate extends core_1.Command {
+    static description = `Check or update the local ${auth_core_1.FIRST_PARTY_HARNESS.displayName} signed release; use --daemon to update another machine`;
     static examples = [
         '<%= config.bin %> code update',
+        '<%= config.bin %> code update --check',
         '<%= config.bin %> code update --daemon <daemon-id>',
-        '<%= config.bin %> code update --json',
+        '<%= config.bin %> code update --rollback',
     ];
     static flags = {
-        daemon: core_1.Flags.string({
-            description: 'Which daemon runs the update. Defaults to this machine on a Dedicated Runtime, otherwise to the only active one; required when you have several.',
-        }),
+        daemon: core_1.Flags.string({ description: 'Run the update on this daemon instead of this computer' }),
         wait: core_1.Flags.boolean({
             default: true,
             allowNo: true,
-            description: 'Follow the update job until it finishes. --no-wait returns the job id.',
+            description: 'Wait for completion. --no-wait returns the local process or remote job.',
         }),
         json: core_1.Flags.boolean({ description: 'Emit the result as JSON' }),
+        check: core_1.Flags.boolean({
+            description: 'Check the signed release channel without downloading or changing the engine',
+        }),
+        'target-version': core_1.Flags.string({ description: 'Install this exact signed release' }),
+        'allow-downgrade': core_1.Flags.boolean({
+            description: 'Allow an explicitly pinned older signed release',
+        }),
+        rollback: core_1.Flags.boolean({ description: 'Restore the previous verified release' }),
+        'startup-checks': core_1.Flags.string({
+            options: ['on', 'off'],
+            description: 'Enable or disable new-session update checks without updating the engine',
+        }),
     };
     async run() {
-        const { flags } = await this.parse(CodeUpdate);
-        const daemonId = this.updateTarget(await this.resolveTarget(flags.daemon));
-        // Ask the inventory before posting: a daemon older than managed updates has
-        // no handler for the request and would leave it to time out, and an engine
-        // that updates some other way has a reason the daemon already words.
-        let inventory;
-        try {
-            inventory = await (0, cli_installers_1.listCliInstallers)(daemonId, this.resolvedCredential);
-        }
-        catch (err) {
-            this.handleApiError(err);
-        }
-        const row = (inventory.providers ?? []).find((p) => (0, auth_core_1.isFirstPartyHarnessProvider)(p.provider));
-        if (!row) {
-            this.failWithCliError({
-                message: `${auth_core_1.FIRST_PARTY_HARNESS.displayName} is not installed on ${daemonId}. ` +
-                    `Install it with \`${this.config.bin} code install\`.`,
-                code: 'NOT_INSTALLED',
-                exit: 1,
-                retryable: false,
-            });
-        }
-        if (row.updatable === undefined) {
-            this.failWithCliError({
-                message: `The daemon ${daemonId} (${inventory.daemonVersion ?? 'version not reported'}) cannot update ${auth_core_1.FIRST_PARTY_HARNESS.displayName}: it predates managed updates. ` +
-                    `Update the daemon, then run this again.`,
-                code: 'DAEMON_UPDATE_UNSUPPORTED',
-                exit: 1,
-                retryable: false,
-            });
-        }
-        if (!row.updatable) {
-            this.failWithCliError({
-                message: row.updateDisabledReason?.trim() ||
-                    `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: the daemon cannot update it here.`,
-                code: 'CLI_NOT_UPDATABLE',
-                exit: 1,
-                retryable: false,
-            });
+        // Preserve all authenticated remote flags (--profile, --workspace, --token)
+        // without importing or initializing the auth stack for a local operation.
+        if (this.argv.some((arg) => arg === '--daemon' || arg.startsWith('--daemon='))) {
+            const { default: RemoteCodeUpdate } = await Promise.resolve().then(() => __importStar(require('../../lib/first-party-harness-remote-update')));
+            await this.parse(RemoteCodeUpdate);
+            await RemoteCodeUpdate.run(this.argv, this.config);
+            return;
         }
-        const start = await this.start(daemonId, flags.json === true);
-        if (!start)
+        const { flags } = await this.parse(CodeUpdate);
+        if (flags['startup-checks']) {
+            if (flags.daemon ||
+                flags.check ||
+                flags.rollback ||
+                flags['target-version'] ||
+                flags['allow-downgrade'] ||
+                !flags.wait)
+                this.error('--startup-checks changes only the local preference; use it without other update controls.');
+            const setting = (0, first_party_harness_startup_update_1.configureCodeStartupChecks)(flags['startup-checks'] === 'on');
+            if (flags.json)
+                this.log(JSON.stringify({
+                    component: 'code',
+                    state: 'configured',
+                    startupChecks: setting.enabled,
+                    preferencesPath: setting.preferencesPath,
+                }, null, 2));
+            else
+                this.log(`${auth_core_1.FIRST_PARTY_HARNESS.displayName} startup update checks ${setting.enabled ? 'enabled' : 'disabled'}. Change this with \`skrr code update --startup-checks ${setting.enabled ? 'off' : 'on'}\`.`);
             return;
-        const jobId = start.job?.id;
-        if (!start.started || !jobId) {
-            if (flags.json) {
-                this.log(JSON.stringify({ daemonId, ...start }, null, 2));
+        }
+        if (flags.rollback &&
+            (flags.check || flags['target-version'] || flags['allow-downgrade'] || !flags.wait))
+            this.error('--rollback cannot be combined with --check, --target-version, --allow-downgrade or --no-wait.');
+        if (flags['allow-downgrade'] && !flags['target-version'])
+            this.error('--allow-downgrade requires --target-version.');
+        const options = {
+            version: flags['target-version'],
+            allowDowngrade: flags['allow-downgrade'],
+            force: true,
+        };
+        try {
+            const current = (0, first_party_harness_update_1.getLocalCodeUpdateStatus)();
+            if (!flags.check && !flags.rollback && !current.activePath && current.owner === 'managed') {
+                const missing = {
+                    ...current,
+                    state: 'failed',
+                    code: 'NOT_INSTALLED',
+                    message: `${auth_core_1.FIRST_PARTY_HARNESS.displayName} is not installed on this computer. Run \`skrr code install\`.`,
+                };
+                if (flags.json)
+                    this.log(JSON.stringify(missing, null, 2));
+                else
+                    this.log((0, first_party_harness_update_1.formatLocalCodeUpdate)(missing));
+                process.exitCode = 1;
                 return;
             }
-            this.log(start.alreadyRunning
-                ? `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: an install or update is already running (job ${start.job?.id ?? 'unknown'}).`
-                : `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: ${start.provider?.updateDisabledReason?.trim() || 'the daemon started no update job.'}`);
-            return;
-        }
-        if (!flags.wait) {
-            if (flags.json) {
-                this.log(JSON.stringify({ daemonId, ...start }, null, 2));
+            if (!flags.check && !flags.rollback && !flags.wait) {
+                const queued = await (0, first_party_harness_update_1.startLocalCodeUpdate)(options);
+                if (flags.json)
+                    this.log(JSON.stringify(queued, null, 2));
+                else
+                    this.log(`${auth_core_1.FIRST_PARTY_HARNESS.displayName} update queued (process ${queued.pid}). Results: ${queued.logPath}; status: skrr code doctor.`);
                 return;
             }
-            this.log(`Update started on ${daemonId} — job ${jobId}.`);
-            return;
-        }
-        if (!flags.json) {
-            this.logToStderr(`Updating ${auth_core_1.FIRST_PARTY_HARNESS.displayName} ${row.version ? `${row.version} ` : ''}on ${daemonId}…`);
-        }
-        const job = await this.follow(daemonId, jobId, flags.json === true);
-        if (!job)
-            return;
-        if (flags.json) {
-            this.log(JSON.stringify({ daemonId, job }, null, 2));
-            if (job.status !== 'succeeded')
+            const result = flags.check
+                ? await (0, first_party_harness_update_1.checkLocalCodeUpdate)(options)
+                : flags.rollback
+                    ? (0, first_party_harness_update_1.rollbackLocalCode)()
+                    : await (0, first_party_harness_update_1.updateLocalCode)({
+                        ...options,
+                        onProgress: flags.json ? undefined : (line) => this.logToStderr(line),
+                    });
+            if (flags.json)
+                this.log(JSON.stringify(result, null, 2));
+            else
+                this.log((0, first_party_harness_update_1.formatLocalCodeUpdate)(result));
+            if (result.state === 'failed' || result.state === 'check-failed')
                 process.exitCode = 1;
-            return;
-        }
-        if (job.status === 'failed') {
-            this.failWithCliError({
-                message: job.error || 'The update failed and the daemon gave no reason.',
-                code: 'UPDATE_FAILED',
-                exit: 1,
-                retryable: false,
-            });
         }
-        this.log((0, cli_installers_1.updateOutcomeLine)(job) ??
-            `${auth_core_1.FIRST_PARTY_HARNESS.displayName} updated${job.installedVersion ? ` to ${job.installedVersion}` : ''}.`);
-    }
-    /** Which daemon the update targets, by the rule every daemon-picking command shares. */
-    async resolveTarget(explicit) {
-        try {
-            return await (0, daemon_target_1.resolveDaemonTarget)({
-                explicit,
-                local: (0, daemon_target_1.localMachine)({ baseURL: this.cliConfig?.baseURL }),
-                listActiveDaemons: () => (0, daemon_target_1.listConnectedDaemons)(this.resolvedCredential),
-            });
-        }
-        catch (err) {
-            this.handleApiError(err);
-        }
-    }
-    /**
-     * The daemon id to update through, or the refusal — identical rules to
-     * `code install`: a Dedicated Runtime's own machine is image-managed, several
-     * connected daemons get named rather than guessed.
-     */
-    updateTarget(target) {
-        if (target.kind === 'daemon')
-            return target.daemonId;
-        if (target.kind === 'this-machine') {
-            this.failWithCliError({
-                message: target.explicit
-                    ? first_party_harness_1.DEDICATED_RUNTIME_ENGINE_MESSAGE
-                    : `${first_party_harness_1.DEDICATED_RUNTIME_ENGINE_MESSAGE} This command updates the machine it runs on; ` +
-                        'to update another of your machines, name it with --daemon.',
-                code: 'DEDICATED_RUNTIME_ENGINE_SHIPS_WITH_IMAGE',
-                exit: 1,
-                retryable: false,
-            });
-        }
-        if (target.kind === 'none') {
-            this.failWithCliError({
-                message: 'No daemon is connected for this account, so nothing can perform the update. ' +
-                    `Start the background service on this computer with \`${this.config.bin} daemon start\`, then run this again.`,
-                code: 'NO_DAEMON',
-                exit: 1,
-                retryable: false,
-            });
-        }
-        const { daemons } = target;
-        const choices = daemons
-            .slice(0, 10)
-            .map((d) => `  ${d.id}  ${d.name || '—'}`)
-            .join('\n');
-        this.failWithCliError({
-            message: `${daemons.length} connected daemons — say which machine should update the engine:\n${choices}\n` +
-                `Pass one with --daemon, or see each daemon id in the DAEMON ID column of \`${this.config.bin} harnesses list\`.`,
-            code: 'AMBIGUOUS_DAEMON',
-            exit: 1,
-            retryable: false,
-        });
-    }
-    /**
-     * Start the update, and survive a gateway that cut the request off — the same
-     * 504 recovery `harnesses install --update` uses: the relay can drop the
-     * answer while the daemon runs the job it started, so on a server-side
-     * failure we ask the daemon and follow the job it reports.
-     */
-    async start(daemonId, json) {
-        try {
-            return await (0, cli_installers_1.startManagedCliUpdate)(daemonId, PROVIDER, this.resolvedCredential);
-        }
-        catch (err) {
-            const status = err.status ?? 0;
-            if (status >= 500 || status === 408) {
-                const job = await (0, cli_installers_1.jobStartedDespiteTimeout)(daemonId, PROVIDER, this.resolvedCredential);
-                if (job?.id) {
-                    if (!json) {
-                        this.logToStderr(`The request to ${daemonId} did not come back (HTTP ${status}), but the daemon started job ${job.id}. Following it.`);
-                    }
-                    return { started: true, job };
-                }
+        catch (error) {
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    component: 'code',
+                    state: 'failed',
+                    error: error instanceof Error ? error.message : String(error),
+                }));
+                process.exitCode = 1;
             }
-            this.handleApiError(err);
-            return undefined;
-        }
-    }
-    /** Follow a job to its end, or report why it could not be followed (and return nothing). */
-    async follow(daemonId, jobId, json) {
-        const outcome = await (0, cli_installers_1.followManagedCliInstallJob)({
-            daemonId,
-            jobId,
-            credential: this.resolvedCredential,
-            onLogLine: json ? undefined : (line) => this.logToStderr(`  ${line}`),
-        });
-        if (outcome.kind === 'missing') {
-            this.failWithCliError({
-                message: `The daemon no longer has update job ${jobId}.`,
-                code: 'JOB_MISSING',
-                exit: 1,
-                retryable: false,
-            });
-            return undefined;
-        }
-        if (outcome.kind === 'timeout') {
-            this.failWithCliError({
-                message: `Still updating after ${Math.round(cli_installers_1.INSTALL_MAX_WAIT_MS / 60000)} minutes — the daemon is ` +
-                    `still working on job ${jobId}. Check \`${this.config.bin} code doctor\` in a while.`,
-                code: 'UPDATE_PENDING',
-                exit: 1,
-                retryable: true,
-            });
-            return undefined;
+            else
+                this.error(error instanceof Error ? error : String(error));
         }
-        return outcome.job;
     }
 }
 exports.default = CodeUpdate;
-/** Same canonical provider id `code install` posts — read from the identity module. */
-const PROVIDER = auth_core_1.FIRST_PARTY_HARNESS.provider;

package/dist/commands/commitments/{autonomy-requests → cadence-requests}/decide.d.ts

@@ -1,16 +1,14 @@
 import { BaseCommand } from '../../../base-command';
 /**
- * `skrr commitments autonomy-requests decide <id> <request-id> --approve`
+ * `skrr commitments cadence-requests decide <id> <request-id> --approve`
  *
- * When an Agent proposes changing its own commitment's cadence, the server does
- * NOT apply it — it parks a durable request (`state.pendingAutonomyRequests`)
- * and waits. This is the command that answers one. Approving materializes the
- * wake through the same resolver a bypass-mode agent would have used; rejecting
- * records the no and leaves the cadence alone.
+ * The server records concrete cadence proposals requiring an owner decision.
+ * Approval changes only the check schedule; it grants no execution permissions.
+ * Rejection records the decision and leaves the schedule unchanged.
  *
  * List the pending ones with `skrr commitments show <id>`.
  */
-export default class CommitmentsAutonomyRequestsDecide extends BaseCommand {
+export default class CommitmentsCadenceRequestsDecide extends BaseCommand {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/commitments/{autonomy-requests → cadence-requests}/decide.js

@@ -4,44 +4,42 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../../base-command");
 const commitments_1 = require("../../../lib/commitments");
 /**
- * `skrr commitments autonomy-requests decide <id> <request-id> --approve`
+ * `skrr commitments cadence-requests decide <id> <request-id> --approve`
  *
- * When an Agent proposes changing its own commitment's cadence, the server does
- * NOT apply it — it parks a durable request (`state.pendingAutonomyRequests`)
- * and waits. This is the command that answers one. Approving materializes the
- * wake through the same resolver a bypass-mode agent would have used; rejecting
- * records the no and leaves the cadence alone.
+ * The server records concrete cadence proposals requiring an owner decision.
+ * Approval changes only the check schedule; it grants no execution permissions.
+ * Rejection records the decision and leaves the schedule unchanged.
  *
  * List the pending ones with `skrr commitments show <id>`.
  */
-class CommitmentsAutonomyRequestsDecide extends base_command_1.BaseCommand {
+class CommitmentsCadenceRequestsDecide extends base_command_1.BaseCommand {
     static description = 'Approve or reject an agent-proposed commitment cadence change';
     static examples = [
-        '<%= config.bin %> commitments autonomy-requests decide obj_abc123 req_xyz --approve',
-        '<%= config.bin %> commitments autonomy-requests decide obj_abc123 req_xyz --reject',
+        '<%= config.bin %> commitments cadence-requests decide obj_abc123 req_xyz --approve',
+        '<%= config.bin %> commitments cadence-requests decide obj_abc123 req_xyz --reject',
     ];
     static args = {
         commitmentId: core_1.Args.string({ ignoreStdin: true, description: 'Commitment ID', required: true }),
         requestId: core_1.Args.string({
             ignoreStdin: true,
-            description: 'Pending autonomy request ID',
+            description: 'Pending cadence request ID',
             required: true,
         }),
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
-        approve: core_1.Flags.boolean({ description: 'Approve and materialize', exclusive: ['reject'] }),
+        approve: core_1.Flags.boolean({ description: 'Approve the cadence change', exclusive: ['reject'] }),
         reject: core_1.Flags.boolean({ description: 'Reject the proposal', exclusive: ['approve'] }),
     };
     async run() {
         this.requireAuth();
-        const { args, flags } = await this.parse(CommitmentsAutonomyRequestsDecide);
+        const { args, flags } = await this.parse(CommitmentsCadenceRequestsDecide);
         if (!flags.approve && !flags.reject) {
             this.error('Pass --approve or --reject.');
         }
         let result;
         try {
-            result = await commitments_1.commitmentApi.decideAutonomyRequest(args.commitmentId, args.requestId, Boolean(flags.approve));
+            result = await commitments_1.commitmentApi.decideCadenceRequest(args.commitmentId, args.requestId, Boolean(flags.approve));
         }
         catch (err) {
             this.handleApiError(err);
@@ -51,8 +49,8 @@ class CommitmentsAutonomyRequestsDecide extends base_command_1.BaseCommand {
             return;
         }
         this.log(flags.approve
-            ? `Approved ${args.requestId} — the proposed wake was materialized.`
+            ? `Approved ${args.requestId} — the proposed cadence was applied.`
             : `Rejected ${args.requestId} — the cadence is unchanged.`);
     }
 }
-exports.default = CommitmentsAutonomyRequestsDecide;
+exports.default = CommitmentsCadenceRequestsDecide;

package/dist/commands/commitments/cost.d.ts

@@ -32,7 +32,7 @@ export declare function resolveCostWindow(input?: {
  * Money on this path has no other bound the operator can read: a Commitment's
  * agent turns are `AgentOutcome` rows carrying no cost fields, so
  * `spendLimitDailyUsd` cannot see them and `maxRunsPerDay` IS the spend control
- * (see `autonomyEnvelope.maxRunsPerDay` in the API's own schema note). This is
+ * (see `executionBudget.maxRunsPerDay` in the API's own schema note). This is
  * the read that says what those runs actually cost.
  *
  * `metrics` shows the daily rows; this sums the closed ones over a window and,

package/dist/commands/commitments/cost.js

@@ -50,7 +50,7 @@ function resolveCostWindow(input = {}, now = new Date()) {
  * Money on this path has no other bound the operator can read: a Commitment's
  * agent turns are `AgentOutcome` rows carrying no cost fields, so
  * `spendLimitDailyUsd` cannot see them and `maxRunsPerDay` IS the spend control
- * (see `autonomyEnvelope.maxRunsPerDay` in the API's own schema note). This is
+ * (see `executionBudget.maxRunsPerDay` in the API's own schema note). This is
  * the read that says what those runs actually cost.
  *
  * `metrics` shows the daily rows; this sums the closed ones over a window and,

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

@@ -26,11 +26,6 @@ export declare function createCadenceFromFlags({ eventDriven, cadence: cadenceIn
  * be said out loud at the CLI boundary; otherwise a successful create response
  * reads like the requested autonomy is live when something else is running.
  */
-export declare function autonomyStagingNotice({ payload, commitment, bin, }: {
-    payload: Record<string, unknown>;
-    commitment: Record<string, unknown>;
-    bin: string;
-}): string | undefined;
 /**
  * `skrr commitments create` — author a durable commitment contract.
  *
@@ -70,11 +65,9 @@ export default class CommitmentsCreate extends BaseCommand {
         'event-driven': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'cadence-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         timezone: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         delivery: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         repo: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         base: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        autonomy: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         isolation: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'max-nudges': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'max-concurrent-runs': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;