@skrr-ai/cli 0.1.118 → 0.1.120

package/dist/commands/goals/planner-compare.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparisonLines = comparisonLines;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+/** The board fields in the order the server records them. */
+const BOARD_ROWS = [
+    ['open', 'open tasks (capacity)'],
+    ['notStarted', 'not started (refinable)'],
+    ['executing', 'running or in review'],
+    ['failed', 'failed'],
+    ['completed', 'completed'],
+    ['keyResults', 'key results'],
+    ['keyResultsDone', '  judged done'],
+    ['keyResultsAtRisk', '  judged at risk'],
+    ['keyResultsOffTrack', '  judged off track'],
+];
+const DAY_MS = 24 * 60 * 60 * 1000;
+function countsLine(total, byKey) {
+    const parts = Object.entries(byKey)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, count]) => `${key} ${count}`);
+    return parts.length ? `${total} (${parts.join(', ')})` : String(total);
+}
+function holderNowLabel(current) {
+    if (current.holder === 'goal_planner')
+        return 'the Goal planner';
+    if (current.holder === 'goal_loop') {
+        return `the goal_advance loop ${current.commitmentId ?? ''}`.trim();
+    }
+    return 'unknown (could not be read)';
+}
+/** The comparison as the lines the command prints. Pure, so it is tested as such. */
+function comparisonLines(result) {
+    const lines = [];
+    lines.push(`Planning turn now: ${holderNowLabel(result.current)}`);
+    lines.push(`Window:            ${result.since} to ${result.until}`);
+    if (result.cadence.tickIntervalMs) {
+        lines.push(`Planner cadence:   every ${Math.round(result.cadence.tickIntervalMs / 60_000)} min`);
+    }
+    if (result.goalLoop.loops.length) {
+        lines.push(`Loops:             ${result.goalLoop.loops.join(', ')}`);
+    }
+    lines.push('');
+    const width = 30;
+    const column = 22;
+    const pad = (value) => value.padEnd(width);
+    lines.push(`${pad('')}${'Planner'.padEnd(column)}Loop`);
+    lines.push(`${pad('Planner ticks held')}${String(result.goalPlanner.ticks).padEnd(column)}${result.goalLoop.ticks}`);
+    const plannerTurns = Object.values(result.goalPlanner.notes).reduce((a, b) => a + b, 0);
+    lines.push(`${pad('Turns')}${countsLine(plannerTurns, result.goalPlanner.notes).padEnd(column)}${countsLine(result.goalLoop.turns.total, result.goalLoop.turns.byStatus)}`);
+    lines.push(`${pad('Tasks created')}${String(result.goalPlanner.created).padEnd(column)}${result.goalLoop.tasksCreated}`);
+    lines.push(`${pad('Tasks refined')}${String(result.goalPlanner.refined).padEnd(column)}not counted`);
+    lines.push(`${pad('Key results judged')}${'never'.padEnd(column)}${result.goalLoop.keyResultJudgments}`);
+    lines.push('The Goal per planner tick (mean / peak):');
+    for (const [field, label] of BOARD_ROWS) {
+        const planner = result.goalPlanner.board[field];
+        const loop = result.goalLoop.board[field];
+        lines.push(`  ${label.padEnd(width - 2)}${`${planner.mean} / ${planner.peak}`.padEnd(column)}${loop.mean} / ${loop.peak}`);
+    }
+    lines.push('');
+    lines.push(result.concurrentTurns === 0
+        ? 'Concurrent turns:  0'
+        : `Concurrent turns:  ${result.concurrentTurns} (a planner turn and a loop turn overlapped; see the planner ticks and the loop Cycles)`);
+    if (result.unreadableTicks > 0) {
+        lines.push(`Unreadable ticks:  ${result.unreadableTicks} (the holder could not be read, so the planner stood down)`);
+    }
+    if (result.coverage.truncated) {
+        lines.push(`The Goal keeps its most recent planner ticks only; this window reaches back before ${result.coverage.recordedSince}. Narrow it.`);
+    }
+    if (result.truncated) {
+        lines.push('This window holds more loop runs than one comparison reads; narrow it.');
+    }
+    if (result.goalPlanner.ticks + result.goalLoop.ticks === 0) {
+        lines.push('No planner tick in this window recorded who held the turn. A tick records it only when the Goal has a planner cadence and the tick claims the Goal.');
+    }
+    return lines;
+}
+/**
+ * `skrr goals planner-compare <goal-id>` (OSK-18012): GoalPlanner beside the
+ * Goal's `goal_advance` loop, read from `GET /api/goals/:goalId/planning-comparison`.
+ *
+ * What it is for: the evidence to retire the planner for this Goal. Over a
+ * window of at least seven days in which each holder held the Goal: the loop
+ * turned at the Goal's pace (its turns and the planner ticks it held), it judged
+ * the key results (the planner never does), its open and failed work is no
+ * worse than the planner's, the key results it held over moved no worse, and
+ * concurrent turns are 0. Every stop of the loop is explained in its Cycles
+ * (`commitments cycles <id>`).
+ */
+class GoalsPlannerCompare extends base_command_1.BaseCommand {
+    static description = "Compare the Goal planner with the Goal's goal_advance loop: who held the planning turn, the Goal each held it over, and whether their turns overlapped";
+    static examples = [
+        '<%= config.bin %> goals planner-compare <goal-id>',
+        '<%= config.bin %> goals planner-compare <goal-id> --days 14',
+        '<%= config.bin %> goals planner-compare <goal-id> --since 2026-10-01T00:00:00Z --until 2026-10-15T00:00:00Z --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Goal ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        days: core_1.Flags.integer({
+            description: 'Window ending now, in days (default 7, at most 90)',
+            min: 1,
+            max: 90,
+            exclusive: ['since'],
+        }),
+        since: core_1.Flags.string({ description: 'Window start (ISO 8601)' }),
+        until: core_1.Flags.string({ description: 'Window end (ISO 8601; default now)' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(GoalsPlannerCompare);
+        const until = flags.until;
+        const since = flags.since ??
+            (flags.days
+                ? new Date((until ? Date.parse(until) : Date.now()) - flags.days * DAY_MS).toISOString()
+                : undefined);
+        let result;
+        try {
+            result = await data_provider_1.dataService.getGoalPlanningComparison(args.id, { since, until });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.printJsonResult(result);
+            return;
+        }
+        for (const line of comparisonLines(result))
+            this.log(line);
+    }
+}
+exports.default = GoalsPlannerCompare;

package/dist/commands/machines/dedicated/service/exec.d.ts

@@ -1,4 +1,5 @@
 import { DedicatedServiceCommand } from '../../../../lib/dedicated-service-command';
+export declare const SERVICE_EXEC_REQUEST_ID_PATTERN: RegExp;
 /**
  * `skrr machines dedicated service exec` — a one-off command inside a
  * service's context (phase 2).
@@ -21,6 +22,8 @@ export default class DedicatedServiceExec extends DedicatedServiceCommand {
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         timeout: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        inspect: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/machines/dedicated/service/exec.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVICE_EXEC_REQUEST_ID_PATTERN = void 0;
 const core_1 = require("@oclif/core");
+const node_crypto_1 = require("node:crypto");
 const dedicated_service_command_1 = require("../../../../lib/dedicated-service-command");
+const dedicated_service_1 = require("../../../../lib/dedicated-service");
 const exec_1 = require("../../hosted/exec");
+exports.SERVICE_EXEC_REQUEST_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
 /**
  * `skrr machines dedicated service exec` — a one-off command inside a
  * service's context (phase 2).
@@ -18,6 +22,8 @@ class DedicatedServiceExec extends dedicated_service_command_1.DedicatedServiceC
     static examples = [
         '<%= config.bin %> machines dedicated service exec <lease-id> <name> -- printenv',
         '<%= config.bin %> machines dedicated service exec <lease-id> <name> -- cat /workspace/services/name/state.json',
+        '<%= config.bin %> machines dedicated service exec <lease-id> <name> --request-id deploy-42 -- ./deploy.sh',
+        '<%= config.bin %> machines dedicated service exec <lease-id> <name> --request-id deploy-42 --inspect',
     ];
     static usage = 'machines dedicated service exec <lease-id> <name> -- <command...>';
     static args = {
@@ -41,34 +47,87 @@ class DedicatedServiceExec extends dedicated_service_command_1.DedicatedServiceC
             min: 1,
             max: 600,
         }),
+        'request-id': core_1.Flags.string({
+            description: 'Stable idempotency key for this command. Reusing it returns the same durable execution receipt instead of running another command.',
+        }),
+        inspect: core_1.Flags.boolean({
+            description: 'Read an existing execution receipt only. Requires --request-id and never starts a command.',
+        }),
     };
     async run() {
         this.requireAuth();
         const { head, tail } = (0, exec_1.splitExecArgv)(this.argv);
         const { args, flags } = await this.parse(DedicatedServiceExec, head);
         const argv = tail ?? args.command ?? [];
-        if (argv.length === 0) {
+        if (flags.inspect && !flags['request-id']) {
+            this.error('--inspect requires --request-id.', { exit: 2 });
+        }
+        if (flags.inspect && argv.length > 0) {
+            this.error('--inspect is read-only; do not pass a command.', { exit: 2 });
+        }
+        if (!flags.inspect && argv.length === 0) {
             this.error('Command is required — pass it after --.', { exit: 2 });
         }
+        const requestId = flags['request-id'] ?? `svc-exec:${(0, node_crypto_1.randomUUID)()}`;
+        if (!exports.SERVICE_EXEC_REQUEST_ID_PATTERN.test(requestId)) {
+            this.error('--request-id must be 1-128 characters of letters, digits and . _ : -.', {
+                exit: 2,
+            });
+        }
         const leaseId = await this.resolveLeaseArg(args.lease);
         // Phase-2 verb: `dedicated:service:exec {leaseId, name, argv}`. A daemon
         // without the extension answers with the unsupported path — the command
         // degrades, it does not improvise.
         const timeoutSeconds = flags.timeout ?? 300;
-        const result = await this.callService('exec', {
-            leaseId,
-            name: args.name,
-            argv,
-            timeoutSeconds,
-            ...this.scopeFrom(flags),
-        }, 
-        // The relay waits timeoutSeconds+30s; the caller must outlive that or a
-        // legitimately long exec reports a false connectivity failure.
-        (timeoutSeconds + 45) * 1000);
+        let result;
+        try {
+            // Do not use the generic helper: if this long call loses its socket
+            // response, the exact same request id is the recovery subject and the
+            // next safe action is inspection, not a fresh command invocation.
+            const channel = await this.serviceChannel();
+            const response = await channel.call('exec', {
+                leaseId,
+                name: args.name,
+                ...(flags.inspect ? { inspect: true } : { argv, timeoutSeconds }),
+                requestId,
+                ...this.scopeFrom(flags),
+            }, (timeoutSeconds + 45) * 1000);
+            result = response.result;
+        }
+        catch (error) {
+            if (error instanceof dedicated_service_1.DedicatedServiceError &&
+                ['SERVICE_CALL_TIMEOUT', 'disconnected'].includes(error.code)) {
+                this.failWithCliError({
+                    message: 'Could not confirm how this service command ended. It may still be running or may have finished. ' +
+                        `Inspect before retrying: \`${this.config.bin} machines dedicated service exec ${leaseId} ${args.name} --request-id ${requestId} --inspect\`.`,
+                    code: 'DEDICATED_SERVICE_EXECUTION_UNCONFIRMED',
+                    exit: 1,
+                    retryable: true,
+                });
+            }
+            this.reportServiceError(error);
+        }
         this.closeServiceChannel();
+        const execution = result?.execution;
+        if (!flags.inspect && execution?.receipt?.state && execution.receipt.state !== 'completed') {
+            this.failWithCliError({
+                message: `Execution ${execution.operationId ?? requestId} is ${execution.receipt.state}; ` +
+                    `inspect it before retrying: \`${execution.inspection?.command ??
+                        `${this.config.bin} machines dedicated service exec ${leaseId} ${args.name} --request-id ${requestId} --inspect`}\`.`,
+                code: 'DEDICATED_SERVICE_EXECUTION_OUTCOME_UNKNOWN',
+                exit: 1,
+                retryable: true,
+            });
+        }
         if (flags.json) {
             this.log(JSON.stringify(result ?? {}, null, 2));
         }
+        else if (flags.inspect) {
+            const state = execution?.receipt?.state ?? 'unknown';
+            const subject = execution?.operationId ?? `request ${requestId}`;
+            this.log(`Execution ${subject}: ${state}.`);
+            return;
+        }
         else {
             // Binary-safe: the wire contract is base64 — write the decoded bytes
             // verbatim; a debug verb that utf8-mangles or appends newlines lies

package/dist/commands/machines/hosted/destroy.d.ts

@@ -7,6 +7,7 @@ export default class HostedMachinesDestroy extends BaseCommand {
     };
     static flags: {
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/machines/hosted/destroy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
+const node_crypto_1 = require("node:crypto");
 const base_command_1 = require("../../../base-command");
 const hosted_machines_1 = require("../../../lib/hosted-machines");
 class HostedMachinesDestroy extends base_command_1.BaseCommand {
@@ -18,14 +19,18 @@ class HostedMachinesDestroy extends base_command_1.BaseCommand {
     };
     static flags = {
         workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+        'request-id': core_1.Flags.string({
+            description: 'Idempotency key. Reuse it after a lost response to inspect the same destroy request.',
+        }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(HostedMachinesDestroy);
+        const requestId = flags['request-id'] || newRequestId();
         let response;
         try {
-            response = await (0, hosted_machines_1.destroyHostedMachine)(args.id, { workspaceId: flags.workspace });
+            response = await (0, hosted_machines_1.destroyHostedMachine)(args.id, { workspaceId: flags.workspace, requestId });
         }
         catch (err) {
             const message = (0, hosted_machines_1.formatHostedMachineApiError)(err, { bin: this.config.bin });
@@ -38,6 +43,11 @@ class HostedMachinesDestroy extends base_command_1.BaseCommand {
             return;
         }
         this.log(`Hosted Machine ${(0, hosted_machines_1.hostedMachineId)(response.session)} ${(0, hosted_machines_1.hostedMachineStatus)(response.session)}.`);
+        if (response.operation?.id)
+            this.log(`Operation: ${response.operation.id} (${response.operation.state}).`);
     }
 }
 exports.default = HostedMachinesDestroy;
+function newRequestId() {
+    return `skrr-machine-destroy:${Date.now()}:${(0, node_crypto_1.randomBytes)(6).toString('hex')}`;
+}

package/dist/commands/machines/hosted/exec.d.ts

@@ -23,6 +23,7 @@ export default class HostedMachinesExec extends BaseCommand {
         cwd: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         language: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         timeout: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/machines/hosted/exec.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitExecArgv = splitExecArgv;
 const core_1 = require("@oclif/core");
+const node_crypto_1 = require("node:crypto");
 const base_command_1 = require("../../../base-command");
 const shell_quote_1 = require("../../../lib/shell-quote");
 const hosted_machines_1 = require("../../../lib/hosted-machines");
@@ -47,6 +48,9 @@ class HostedMachinesExec extends base_command_1.BaseCommand {
             default: 'shell',
         }),
         timeout: core_1.Flags.string({ description: 'Execution timeout such as 30s, 5m' }),
+        'request-id': core_1.Flags.string({
+            description: 'Idempotency key. Reuse it after a lost response; the command will not run again.',
+        }),
         workspace: core_1.Flags.string({ description: 'Workspace scope' }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };
@@ -91,8 +95,9 @@ class HostedMachinesExec extends base_command_1.BaseCommand {
             ...(timeoutMs ? { timeoutMs } : {}),
         };
         let response;
+        const requestId = flags['request-id'] || newRequestId();
         try {
-            response = await (0, hosted_machines_1.execHostedMachine)(id, body, { workspaceId: flags.workspace });
+            response = await (0, hosted_machines_1.execHostedMachine)(id, body, { workspaceId: flags.workspace, requestId });
         }
         catch (err) {
             const message = (0, hosted_machines_1.formatHostedMachineApiError)(err, { bin: this.config.bin });
@@ -113,6 +118,9 @@ class HostedMachinesExec extends base_command_1.BaseCommand {
                 process.stderr.write(`Note: this command resumed a paused machine — it is billing at the active rate again. ` +
                     `Run \`${this.config.bin} machines hosted pause ${id}\` to park it.\n`);
             }
+            if (response.operation?.id) {
+                process.stderr.write(`Operation: ${response.operation.id} (${response.operation.state}).\n`);
+            }
             if (response.stdout)
                 process.stdout.write(response.stdout);
             if (response.stderr)
@@ -128,3 +136,6 @@ class HostedMachinesExec extends base_command_1.BaseCommand {
     }
 }
 exports.default = HostedMachinesExec;
+function newRequestId() {
+    return `skrr-machine-exec:${Date.now()}:${(0, node_crypto_1.randomBytes)(6).toString('hex')}`;
+}

package/dist/commands/machines/hosted/index.js

@@ -24,6 +24,7 @@ class Machines extends core_1.Command {
         this.log('  skrr machines hosted pause      pause a machine');
         this.log('  skrr machines hosted resume     resume a machine');
         this.log('  skrr machines hosted destroy    terminate a machine');
+        this.log('  skrr machines hosted operation  inspect a durable operation receipt');
     }
 }
 exports.default = Machines;

package/dist/commands/machines/hosted/operation.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../../base-command';
+/** Inspect-only recovery after a response was lost; this never wakes a machine. */
+export default class HostedMachinesOperation extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/hosted/operation.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const hosted_machines_1 = require("../../../lib/hosted-machines");
+/** Inspect-only recovery after a response was lost; this never wakes a machine. */
+class HostedMachinesOperation extends base_command_1.BaseCommand {
+    static description = 'Inspect a Hosted Machine operation receipt without changing the machine';
+    static examples = [
+        '<%= config.bin %> machines hosted operation <operation-id>',
+        '<%= config.bin %> machines hosted operation <operation-id> --json',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Hosted Machine operation id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(HostedMachinesOperation);
+        let response;
+        try {
+            response = await (0, hosted_machines_1.getHostedMachineOperation)(args.id, { workspaceId: flags.workspace });
+        }
+        catch (err) {
+            const message = (0, hosted_machines_1.formatHostedMachineApiError)(err, { bin: this.config.bin });
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.printJsonResult(response);
+            return;
+        }
+        const operation = response.operation;
+        this.log(`Operation: ${operation.id}`);
+        this.log(`Action: ${operation.action}`);
+        this.log(`State: ${operation.state}`);
+        if (operation.sessionId)
+            this.log(`Machine: ${operation.sessionId}`);
+        if (operation.error?.message)
+            this.log(`Error: ${operation.error.message}`);
+    }
+}
+exports.default = HostedMachinesOperation;

package/dist/commands/machines/hosted/pull.js

@@ -243,7 +243,7 @@ function extractArchive(archive, name, destination, overwrite) {
     if (node_fs_1.default.existsSync(destination) && !overwrite) {
         throw new Error(`Local destination already exists: ${destination}. Pass --overwrite to replace it.`);
     }
-    const tmp = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'sky-machine-pull-'));
+    const tmp = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'skrr-machine-pull-'));
     try {
         const archivePath = node_path_1.default.join(tmp, 'archive.tgz');
         const extractDir = node_path_1.default.join(tmp, 'extract');

package/dist/commands/machines/hosted/start.js

@@ -79,9 +79,11 @@ class HostedMachinesStart extends base_command_1.BaseCommand {
                 : {}),
         };
         let session;
+        let operation;
         try {
             const response = await (0, hosted_machines_1.startHostedMachine)(body);
             session = response.session;
+            operation = response.operation;
             const id = (0, hosted_machines_1.hostedMachineId)(session);
             if (flags.repo) {
                 session = await this.waitReadyForFollowup(id, flags.workspace, flags.interval, timeoutMs, flags.json);
@@ -149,11 +151,13 @@ class HostedMachinesStart extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
-            this.log(JSON.stringify({ session }, null, 2));
+            this.log(JSON.stringify({ session, ...(operation ? { operation } : {}) }, null, 2));
             return;
         }
         const id = (0, hosted_machines_1.hostedMachineId)(session);
         this.log(`Hosted Machine ${id || '(unknown)'} ${(0, hosted_machines_1.hostedMachineStatus)(session)}.`);
+        if (operation?.id)
+            this.log(`Operation: ${operation.id} (${operation.state}).`);
         if (session?.egressPolicy) {
             this.log(`Network: ${session.egressPolicy} (${session.egressSource || 'source unknown'}; ${session.egressAllowHosts?.length || 0} hosts)`);
         }
@@ -189,5 +193,5 @@ class HostedMachinesStart extends base_command_1.BaseCommand {
 }
 exports.default = HostedMachinesStart;
 function newRequestId() {
-    return `sky-machine-start:${Date.now()}:${(0, node_crypto_1.randomBytes)(6).toString('hex')}`;
+    return `skrr-machine-start:${Date.now()}:${(0, node_crypto_1.randomBytes)(6).toString('hex')}`;
 }

package/dist/commands/memory/versions/list.d.ts

@@ -1,5 +1,7 @@
 import { ScopedMemoryCommand } from '../../../lib/scoped-memory-command';
 export default class MemoryVersionsList extends ScopedMemoryCommand {
+    static autonomousCredentialPolicy: "bound-session";
+    static sessionReadPolicy: "memory-history-v1";
     static description: string;
     static args: {
         memory: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;

package/dist/commands/memory/versions/list.js

@@ -4,14 +4,15 @@ const list_output_1 = require("../../../lib/list-output");
 const core_1 = require("@oclif/core");
 const scoped_memory_command_1 = require("../../../lib/scoped-memory-command");
 class MemoryVersionsList extends scoped_memory_command_1.ScopedMemoryCommand {
+    static autonomousCredentialPolicy = 'bound-session';
+    static sessionReadPolicy = 'memory-history-v1';
     static description = 'List immutable versions for one Memory topic';
     static args = { memory: core_1.Args.string({ required: true, ignoreStdin: true }) };
     static flags = { ...scoped_memory_command_1.scopedMemoryFlags, limit: core_1.Flags.integer({ default: 100 }) };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(MemoryVersionsList);
-        const store = await this.resolveStore(flags);
-        const result = await this.memoryApi(flags.agent, `/stores/${store.id}/versions${this.query(flags, { memoryId: args.memory, limit: flags.limit })}`);
+        const result = await this.memoryHistoryApi(flags, { memoryId: args.memory, limit: flags.limit });
         if (flags.json)
             return this.printJsonResult((0, list_output_1.listResult)(result, 'versions'));
         for (const version of result.versions)

package/dist/commands/memory/versions/show.d.ts

@@ -1,5 +1,7 @@
 import { ScopedMemoryCommand } from '../../../lib/scoped-memory-command';
 export default class MemoryVersionsShow extends ScopedMemoryCommand {
+    static autonomousCredentialPolicy: "bound-session";
+    static sessionReadPolicy: "memory-history-v1";
     static description: string;
     static args: {
         id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;

package/dist/commands/memory/versions/show.js

@@ -3,14 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const scoped_memory_command_1 = require("../../../lib/scoped-memory-command");
 class MemoryVersionsShow extends scoped_memory_command_1.ScopedMemoryCommand {
+    static autonomousCredentialPolicy = 'bound-session';
+    static sessionReadPolicy = 'memory-history-v1';
     static description = 'Show one immutable MemoryVersion';
     static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
     static flags = scoped_memory_command_1.scopedMemoryFlags;
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(MemoryVersionsShow);
-        const store = await this.resolveStore(flags);
-        const result = await this.memoryApi(flags.agent, `/stores/${store.id}/versions/${encodeURIComponent(args.id)}${this.query(flags)}`);
+        const result = await this.memoryHistoryApi(flags, { versionId: args.id });
         this.print(result, flags.json, `${result.id}  ${result.operation}\n${JSON.stringify(result.payloadSnapshot, null, 2)}`);
     }
 }

package/dist/commands/spaces/auto-executor/compare.d.ts

@@ -0,0 +1,18 @@
+import { type SpaceOrchestrationComparison } from '@skrr-ai/data-provider';
+import { BaseCommand } from '../../../base-command';
+/** The comparison as the lines the command prints. Pure, so it is tested as such. */
+export declare function comparisonLines(result: SpaceOrchestrationComparison): string[];
+export default class SpacesAutoExecutorCompare extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        days: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        since: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        until: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}