@skrr-ai/cli 0.1.23 → 0.1.24

package/dist/commands/machines/dedicated/list.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const format_1 = require("../../../lib/format");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+class DedicatedMachinesList extends base_command_1.BaseCommand {
+    static description = 'List Dedicated Runtime leases';
+    static examples = [
+        '<%= config.bin %> machines dedicated list',
+        '<%= config.bin %> machines dedicated list --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        state: core_1.Flags.string({ description: 'Filter by lease state' }),
+        limit: core_1.Flags.integer({ description: 'Max leases to return', default: 50 }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(DedicatedMachinesList);
+        let response;
+        try {
+            response = await (0, dedicated_machines_1.listDedicatedRuntimes)({
+                limit: flags.limit,
+                state: flags.state,
+            });
+        }
+        catch (err) {
+            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const leases = response?.leases ?? [];
+        if (leases.length === 0) {
+            this.log('No Dedicated Runtime leases.');
+            return;
+        }
+        (0, format_1.renderTable)(leases.map((lease) => ({
+            id: (0, format_1.formatCell)((0, dedicated_machines_1.dedicatedLeaseId)(lease)),
+            status: (0, format_1.formatCell)((0, dedicated_machines_1.dedicatedLeaseState)(lease)),
+            name: (0, format_1.formatCell)((0, dedicated_machines_1.dedicatedLeaseDisplayName)(lease)),
+            retention: (0, format_1.formatCell)(lease.storage?.retentionClass || '-'),
+            backup: (0, format_1.formatCell)(lease.storage?.lastBackupAt || '-'),
+        })), [
+            { key: 'id', header: 'ID' },
+            { key: 'status', header: 'STATUS' },
+            { key: 'name', header: 'NAME', maxWidth: 28 },
+            { key: 'retention', header: 'RETENTION', maxWidth: 14 },
+            { key: 'backup', header: 'LAST BACKUP', maxWidth: 24 },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = DedicatedMachinesList;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class DedicatedMachinesRestart extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/restart.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+class DedicatedMachinesRestart extends base_command_1.BaseCommand {
+    static description = 'Restart a Dedicated Runtime lease';
+    static examples = [
+        '<%= config.bin %> machines dedicated restart <lease-id>',
+        '<%= config.bin %> machines dedicated restart <lease-id> --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: 'Dedicated Runtime lease id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesRestart);
+        let response;
+        try {
+            response = await (0, dedicated_machines_1.performDedicatedLeaseAction)(args.lease, 'restart');
+        }
+        catch (err) {
+            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Dedicated Runtime ${(0, dedicated_machines_1.dedicatedLeaseId)(response?.lease)} ${(0, dedicated_machines_1.dedicatedLeaseState)(response?.lease)}.`);
+    }
+}
+exports.default = DedicatedMachinesRestart;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class DedicatedMachinesShow extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/show.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+class DedicatedMachinesShow extends base_command_1.BaseCommand {
+    static description = 'Show one Dedicated Runtime lease';
+    static examples = [
+        '<%= config.bin %> machines dedicated show <lease-id>',
+        '<%= config.bin %> machines dedicated show <lease-id> --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'Dedicated Runtime lease id',
+            required: true,
+        }),
+    };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesShow);
+        let response;
+        try {
+            response = await (0, dedicated_machines_1.getDedicatedRuntime)(args.lease);
+        }
+        catch (err) {
+            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        const lease = response?.lease;
+        if (!lease) {
+            this.error('Dedicated Runtime lease not found.', { exit: 1 });
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log((0, dedicated_machines_1.dedicatedLeaseDisplayName)(lease));
+        this.log(`  id           ${(0, dedicated_machines_1.dedicatedLeaseId)(lease)}`);
+        this.log(`  status       ${(0, dedicated_machines_1.dedicatedLeaseState)(lease)}`);
+        if (lease.storage?.retentionClass) {
+            this.log(`  retention    ${lease.storage.retentionClass}`);
+        }
+        if (lease.storage?.backupProfile) {
+            this.log(`  backup       ${lease.storage.backupProfile}`);
+        }
+        if (lease.storage?.lastBackupAt) {
+            this.log(`  last backup  ${lease.storage.lastBackupAt}`);
+        }
+        if (lease.billing?.monthlySpendLimitCents != null) {
+            this.log(`  monthly cap  ${lease.billing.monthlySpendLimitCents} cents`);
+        }
+    }
+}
+exports.default = DedicatedMachinesShow;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class DedicatedMachinesSnapshot extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/snapshot.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+class DedicatedMachinesSnapshot extends base_command_1.BaseCommand {
+    static description = 'Snapshot a Dedicated Runtime lease workspace';
+    static examples = [
+        '<%= config.bin %> machines dedicated snapshot <lease-id>',
+        '<%= config.bin %> machines dedicated snapshot <lease-id> --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: 'Dedicated Runtime lease id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesSnapshot);
+        let response;
+        try {
+            response = await (0, dedicated_machines_1.performDedicatedLeaseAction)(args.lease, 'snapshot');
+        }
+        catch (err) {
+            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Dedicated Runtime ${(0, dedicated_machines_1.dedicatedLeaseId)(response?.lease)} ${(0, dedicated_machines_1.dedicatedLeaseState)(response?.lease)}.`);
+    }
+}
+exports.default = DedicatedMachinesSnapshot;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class DedicatedMachinesStart extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+class DedicatedMachinesStart extends base_command_1.BaseCommand {
+    static description = 'Start a Dedicated Runtime lease';
+    static examples = [
+        '<%= config.bin %> machines dedicated start <lease-id>',
+        '<%= config.bin %> machines dedicated start <lease-id> --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: 'Dedicated Runtime lease id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesStart);
+        let response;
+        try {
+            response = await (0, dedicated_machines_1.performDedicatedLeaseAction)(args.lease, 'start');
+        }
+        catch (err) {
+            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Dedicated Runtime ${(0, dedicated_machines_1.dedicatedLeaseId)(response?.lease)} ${(0, dedicated_machines_1.dedicatedLeaseState)(response?.lease)}.`);
+    }
+}
+exports.default = DedicatedMachinesStart;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class DedicatedMachinesStop extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/stop.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+class DedicatedMachinesStop extends base_command_1.BaseCommand {
+    static description = 'Stop a Dedicated Runtime lease';
+    static examples = [
+        '<%= config.bin %> machines dedicated stop <lease-id>',
+        '<%= config.bin %> machines dedicated stop <lease-id> --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: 'Dedicated Runtime lease id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesStop);
+        let response;
+        try {
+            response = await (0, dedicated_machines_1.performDedicatedLeaseAction)(args.lease, 'stop');
+        }
+        catch (err) {
+            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Dedicated Runtime ${(0, dedicated_machines_1.dedicatedLeaseId)(response?.lease)} ${(0, dedicated_machines_1.dedicatedLeaseState)(response?.lease)}.`);
+    }
+}
+exports.default = DedicatedMachinesStop;

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

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 class Machines extends core_1.Command {
-    static description = 'Manage skrr Hosted Machine workspaces';
+    // Paired with `machines dedicated`, and the pairing is the point: this one
+    // resumes, that one restarts. Stated here so the choice can be made without
+    // opening either topic.
+    static description = 'A managed workspace that resumes — files, memory and running processes survive pause';
     static examples = [
         '<%= config.bin %> machines hosted start --name scratch --wait',
         '<%= config.bin %> machines hosted list',

package/dist/commands/spaces/update.js

@@ -76,7 +76,9 @@ class SpacesUpdate extends base_command_1.BaseCommand {
             description: tasks_1.EXPECT_FLAG_HELP +
                 ' This is the space DEFAULT, and it is where the contract actually gets set: nobody ' +
                 'declares one per task, but a space default is configured once and then holds. A ' +
-                'per-task --expect wins. Merged into deliveryPolicy without clobbering its other fields.',
+                'per-task --expect wins. Merged into deliveryPolicy without clobbering its other ' +
+                'fields. Replaces the whole list; pass "clear" to remove the default so new tasks ' +
+                'inherit nothing.',
         }),
         'delivery-mode': core_1.Flags.string({
             options: ['none', 'branch', 'pr', 'pr_automerge', 'direct'],
@@ -132,21 +134,23 @@ class SpacesUpdate extends base_command_1.BaseCommand {
         // Parse before any write: a bad spec must fail here, not reach the server
         // as a silently-dropped field. A space default nobody is enforcing is worse
         // than none, because every task under it then shows a contract that isn't real.
-        let defaultExpectations;
-        if (flags['default-expect'] !== undefined && flags['default-expect'].length > 0) {
-            const parsed = (0, tasks_1.parseExpectations)(flags['default-expect']);
-            if (!parsed.ok) {
-                this.error(parsed.error, { exit: 1 });
-            }
-            else {
-                defaultExpectations = parsed.value;
-            }
+        const resolvedDefaults = (0, tasks_1.resolveDefaultExpectations)(flags['default-expect']);
+        if (!resolvedDefaults.ok) {
+            this.error(resolvedDefaults.error, { exit: 1 });
         }
+        const defaultExpectations = resolvedDefaults.ok ? resolvedDefaults.value : undefined;
         const isolation = flags['worktree-isolation'];
         const deliveryMode = flags['delivery-mode'];
         const integrationBranch = flags['integration-branch'];
         const autoMergeTier = flags['auto-merge-tier'];
-        if (isolation || defaultExpectations || deliveryMode || integrationBranch || autoMergeTier) {
+        // `defaultExpectations === null` is a real instruction (remove the default), so
+        // it must reach the policy merge — a truthiness test dropped it silently and
+        // made `clear` a no-op that printed success.
+        if (isolation ||
+            defaultExpectations !== undefined ||
+            deliveryMode ||
+            integrationBranch ||
+            autoMergeTier) {
             let basePolicy = {};
             if (payload.deliveryPolicy && typeof payload.deliveryPolicy === 'object') {
                 basePolicy = { ...payload.deliveryPolicy };
@@ -169,7 +173,7 @@ class SpacesUpdate extends base_command_1.BaseCommand {
                 ...(deliveryMode ? { mode: deliveryMode } : {}),
                 ...(integrationBranch ? { integrationBranch } : {}),
                 ...(autoMergeTier ? { autoMergeTrustTier: autoMergeTier } : {}),
-                ...(defaultExpectations ? { defaultExpectations } : {}),
+                ...(defaultExpectations !== undefined ? { defaultExpectations } : {}),
             };
         }
         // Goal links are NOT part of the PATCH body — the server rejects a PATCH

package/dist/commands/spaces/work-sync/reconcile.d.ts

@@ -0,0 +1,38 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * `skrr spaces work-sync reconcile <space>` — answer the divergence question
+ * without a browser, and repair what it finds.
+ *
+ * Root `CLAUDE.md` records that two Work Sync exit criteria were knowingly
+ * overridden, and that "an unexplained board divergence is a live hypothesis, not
+ * an impossibility, and is the first thing to suspect." `work-sync telemetry`
+ * reports whether the browser's convergence detector has ever RUN. This answers
+ * the underlying question directly: it compares every published projection entry
+ * against authoritative task truth server-side, and `upserts` is the count that
+ * disagreed.
+ *
+ * That matters because the detector only runs where a board is open. A Space
+ * nobody has visited since the detector shipped reports zero comparisons forever,
+ * which is indistinguishable from health in the telemetry and is not health. This
+ * command needs no board, no browser, and no visitor.
+ *
+ * IT WRITES, and the help says so plainly rather than burying it. The endpoint is
+ * editor-gated because it republishes projection rows that clients will see. It
+ * never mutates task truth — the projection is derived, and a republished card is
+ * a corrected copy of a Task nobody touched — and on a healthy scope it finds
+ * nothing and changes nothing, so the verification and the repair are the same
+ * call. There is deliberately no dry-run flag to add: a read-only variant would be
+ * a second implementation of the comparison, which is how the two answers start
+ * disagreeing.
+ */
+export default class SpacesWorkSyncReconcile extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        space: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/spaces/work-sync/reconcile.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const work_sync_1 = require("../../../lib/work-sync");
+/**
+ * `skrr spaces work-sync reconcile <space>` — answer the divergence question
+ * without a browser, and repair what it finds.
+ *
+ * Root `CLAUDE.md` records that two Work Sync exit criteria were knowingly
+ * overridden, and that "an unexplained board divergence is a live hypothesis, not
+ * an impossibility, and is the first thing to suspect." `work-sync telemetry`
+ * reports whether the browser's convergence detector has ever RUN. This answers
+ * the underlying question directly: it compares every published projection entry
+ * against authoritative task truth server-side, and `upserts` is the count that
+ * disagreed.
+ *
+ * That matters because the detector only runs where a board is open. A Space
+ * nobody has visited since the detector shipped reports zero comparisons forever,
+ * which is indistinguishable from health in the telemetry and is not health. This
+ * command needs no board, no browser, and no visitor.
+ *
+ * IT WRITES, and the help says so plainly rather than burying it. The endpoint is
+ * editor-gated because it republishes projection rows that clients will see. It
+ * never mutates task truth — the projection is derived, and a republished card is
+ * a corrected copy of a Task nobody touched — and on a healthy scope it finds
+ * nothing and changes nothing, so the verification and the repair are the same
+ * call. There is deliberately no dry-run flag to add: a read-only variant would be
+ * a second implementation of the comparison, which is how the two answers start
+ * disagreeing.
+ */
+class SpacesWorkSyncReconcile extends base_command_1.BaseCommand {
+    static description = 'Compare a Space Work Sync projection against task truth and repair what diverged (writes)';
+    static examples = [
+        '<%= config.bin %> spaces work-sync reconcile <space-id>',
+        '<%= config.bin %> spaces work-sync reconcile <space-id> --json',
+    ];
+    static args = {
+        space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SpacesWorkSyncReconcile);
+        let result;
+        try {
+            result = await (0, work_sync_1.reconcileWorkSyncScope)(args.space);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const diverged = (result.upserts || 0) +
+            (result.removes || 0) +
+            (result.summaryUpserts || 0) +
+            (result.summaryRemoves || 0);
+        // Lead with the verdict, because it is the whole reason to run this. A table
+        // of four zeros under no summary line makes the reader do the addition.
+        if (diverged === 0) {
+            this.log('No divergence: every published projection entry matches task truth.');
+        }
+        else {
+            this.log(`Divergence found and repaired: ${diverged} ${diverged === 1 ? 'entry' : 'entries'}.`);
+            this.log('');
+            this.log(`  stale task cards republished   ${result.upserts || 0}`);
+            this.log(`  task cards removed             ${result.removes || 0}`);
+            this.log(`  stale summaries republished    ${result.summaryUpserts || 0}`);
+            this.log(`  summaries removed              ${result.summaryRemoves || 0}`);
+        }
+        if (result.backlog > 0) {
+            this.log('');
+            this.log(`${result.backlog} repair ${result.backlog === 1 ? 'row was' : 'rows were'} already queued ` +
+                'by earlier publish failures. A successful run settles them; one that failed again is kept.');
+        }
+        if (result.truncated) {
+            this.log('');
+            // Never let a partial pass read as a clean one. The scope read is capped at
+            // 1000 rows, so a larger Space was only checked as far as the cap.
+            this.log('PARTIAL: this Space is larger than the 1000-row reconciliation cap, so the ' +
+                'verdict above covers a prefix of it and not the whole Space.');
+        }
+    }
+}
+exports.default = SpacesWorkSyncReconcile;

package/dist/commands/spaces/work-sync/telemetry.d.ts

@@ -0,0 +1,29 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * `skrr spaces work-sync telemetry <space>` — Work Sync's own exit criteria.
+ *
+ * Work Sync v1 is ON at 100% (owner decision, 2026-09-08) with two criteria
+ * knowingly overridden rather than satisfied. The server has computed the verdict
+ * the whole time, and nothing outside the API could read it — so checking the
+ * criteria meant querying the production database by hand, which is why nobody
+ * did. An exit criterion that can only be read by hand is one that does not get
+ * read.
+ *
+ * The verdict is printed as the server decided it. This command does not
+ * re-derive it: the same rule that keeps `tasks expectations` reading the server's
+ * judgement rather than computing its own applies here, and for the same reason —
+ * a CLI that reached a different conclusion from the service would leave the
+ * reader unable to tell which was lying.
+ */
+export default class SpacesWorkSyncTelemetry extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        space: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}