@skrr-ai/cli 0.1.23 → 0.1.25

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/auto-executor/preview.d.ts

@@ -1,3 +1,4 @@
+import { type SpaceAutoExecutorRefillState } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../../base-command';
 export default class SpacesAutoExecutorPreview extends BaseCommand {
     static description: string;
@@ -10,3 +11,10 @@ export default class SpacesAutoExecutorPreview extends BaseCommand {
     };
     run(): Promise<void>;
 }
+/**
+ * The refill latch in words: whether start work is owed, why it last woke, and
+ * what each recent task-pool change did. This is how "the board is not picking
+ * up work" becomes a question with an answer. `undefined` is a server that does
+ * not report it; `null` is one that could not read it, and says so.
+ */
+export declare function refillLines(refill: SpaceAutoExecutorRefillState | null | undefined): string[];

package/dist/commands/spaces/auto-executor/preview.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.refillLines = refillLines;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
@@ -49,6 +50,8 @@ class SpacesAutoExecutorPreview extends base_command_1.BaseCommand {
         if (capacity.budget && !capacity.budget.unlimited) {
             this.log(`Budget:     ${capacity.budget.consumedStarts}/${capacity.budget.maxStarts} starts used this round`);
         }
+        for (const line of refillLines(result.refill))
+            this.log(line);
         const { actions, summary } = plan;
         this.log('');
         this.log(`Board:      ${summary.readyCount} ready · ${summary.unassignedCount} unassigned · ` +
@@ -70,6 +73,44 @@ class SpacesAutoExecutorPreview extends base_command_1.BaseCommand {
     }
 }
 exports.default = SpacesAutoExecutorPreview;
+/**
+ * The refill latch in words: whether start work is owed, why it last woke, and
+ * what each recent task-pool change did. This is how "the board is not picking
+ * up work" becomes a question with an answer. `undefined` is a server that does
+ * not report it; `null` is one that could not read it, and says so.
+ */
+function refillLines(refill) {
+    if (refill === undefined)
+        return [];
+    if (refill === null)
+        return ['Refill:     state unavailable (the server could not read it)'];
+    const owed = refill.requestedGeneration - refill.processedGeneration;
+    const lines = [
+        `Refill:     ${refill.pending
+            ? `${owed} wake${owed === 1 ? '' : 's'} owed (generation ${refill.processedGeneration} → ${refill.requestedGeneration})`
+            : `caught up (generation ${refill.processedGeneration})`}${refill.lastReason ? ` · last: ${refill.lastReason}` : ''}`,
+    ];
+    if (refill.notBefore)
+        lines.push(`            deferred until ${refill.notBefore}`);
+    if (refill.waitingOnAgentIds.length) {
+        lines.push(`            waiting on agent capacity: ${refill.waitingOnAgentIds.join(', ')}`);
+    }
+    const wakes = refill.taskPool.recentWakes;
+    if (wakes.length) {
+        lines.push('');
+        lines.push(`Recent task-pool changes (${wakes.length}):`);
+        for (const wake of wakes) {
+            const effect = wake.refillRelevant === true
+                ? 'can start work'
+                : wake.refillRelevant === false
+                    ? 'nothing to start'
+                    : 'unclassified';
+            const outcome = wake.status === 'processed' ? (wake.decision ?? 'processed') : wake.status;
+            lines.push(`  - #${wake.generation} ${wake.mutation} · ${effect} · ${outcome}`);
+        }
+    }
+    return lines;
+}
 function taskLine(task) {
     return `${task.identifier ? `${task.identifier} ` : ''}${task.title}`;
 }

package/dist/commands/spaces/task-rollups.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr spaces task-rollups` — task-status counts for every Space you can view,
+ * in one request: the same rollup the Spaces sidebar row reads, counted by the
+ * project-rollup rules (`done` is done only; `open` excludes cancelled).
+ */
+export default class SpacesTaskRollups extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/spaces/task-rollups.js

@@ -0,0 +1,66 @@
+"use strict";
+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");
+/**
+ * `skrr spaces task-rollups` — task-status counts for every Space you can view,
+ * in one request: the same rollup the Spaces sidebar row reads, counted by the
+ * project-rollup rules (`done` is done only; `open` excludes cancelled).
+ */
+class SpacesTaskRollups extends base_command_1.BaseCommand {
+    static description = 'Show task-status counts for every space you can view';
+    static examples = [
+        '<%= config.bin %> spaces task-rollups',
+        '<%= config.bin %> spaces task-rollups --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(SpacesTaskRollups);
+        let response;
+        // Titles are best-effort: the rollup carries only ids, and a failed title
+        // lookup must not hide counts the rollup did return.
+        let titles = new Map();
+        try {
+            const [rollups, spaces] = await Promise.all([
+                data_provider_1.dataService.listSpaceTaskRollups(),
+                data_provider_1.dataService.listSpaces({ includeArchived: true, limit: 500 }).catch(() => null),
+            ]);
+            response = rollups;
+            const rows = (spaces?.data ||
+                []);
+            titles = new Map(rows.map((space) => [String(space.id), space.title || '']));
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        if (response.degraded) {
+            // A partial walk is not the whole picture; say so before the numbers.
+            this.log(`Degraded: ${(response.warnings || []).join('; ') || 'some spaces were not counted'}`);
+        }
+        const rows = [...(response.rollups || [])].sort((a, b) => b.tasks.open - a.tasks.open);
+        if (rows.length === 0) {
+            this.log('No spaces with tasks.');
+            return;
+        }
+        const label = (spaceId) => {
+            const title = titles.get(spaceId);
+            const text = title ? `${title} (${spaceId.slice(0, 8)})` : spaceId;
+            return text.length > 48 ? `${text.slice(0, 45)}...` : text;
+        };
+        this.log(`${'SPACE'.padEnd(48)} ${'OPEN'.padStart(5)} ${'DONE'.padStart(5)} ${'BLOCKED'.padStart(7)} ${'TOTAL'.padStart(5)}`);
+        for (const { spaceId, tasks } of rows) {
+            this.log(`${label(spaceId).padEnd(48)} ${String(tasks.open).padStart(5)} ${String(tasks.done).padStart(5)} ` +
+                `${String(tasks.blocked).padStart(7)} ${String(tasks.total).padStart(5)}`);
+        }
+    }
+}
+exports.default = SpacesTaskRollups;

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>;
+}