@skrr-ai/cli 0.1.14 → 0.1.17

package/dist/commands/instruction-blocks/delete.d.ts

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

package/dist/commands/instruction-blocks/delete.js

@@ -0,0 +1,35 @@
+"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");
+const prompt_1 = require("../../lib/prompt");
+class InstructionBlocksDelete extends base_command_1.BaseCommand {
+    static description = 'Archive a block you authored (existing Agent compositions keep their pinned snapshot)';
+    static examples = ['<%= config.bin %> instruction-blocks delete block_… --yes'];
+    static args = {
+        id: core_1.Args.string({ description: 'Instruction block ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        yes: core_1.Flags.boolean({ char: 'y', description: 'Skip confirmation' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(InstructionBlocksDelete);
+        const confirmed = await (0, prompt_1.confirmDestructive)(`Archive ${args.id}? Existing Agents keep their version-pinned snapshot, but it can no longer be newly attached.`, flags.yes);
+        if (!confirmed)
+            return this.log('Aborted.');
+        let result;
+        try {
+            result = await data_provider_1.dataService.archiveInstructionBlock(args.id);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        this.log(`Archived ${result.id}. Existing Agents retain their pinned snapshots.`);
+    }
+}
+exports.default = InstructionBlocksDelete;

package/dist/commands/instruction-blocks/list.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base-command';
+/** List the picker catalog in a form an Agent can act on without a browser. */
+export default class InstructionBlocksList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        official: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        library: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        category: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/instruction-blocks/list.js

@@ -0,0 +1,71 @@
+"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");
+const format_1 = require("../../lib/format");
+const CATEGORIES = [
+    'github',
+    'communication',
+    'research',
+    'output',
+    'planning',
+    'other',
+];
+/** List the picker catalog in a form an Agent can act on without a browser. */
+class InstructionBlocksList extends base_command_1.BaseCommand {
+    static description = 'List reusable Agent instruction blocks (official blocks and your visible library)';
+    static examples = [
+        '<%= config.bin %> instruction-blocks list',
+        '<%= config.bin %> instruction-blocks list --library',
+        '<%= config.bin %> instruction-blocks list --category github --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        official: core_1.Flags.boolean({ description: 'Only code-owned official blocks' }),
+        library: core_1.Flags.boolean({ description: 'Only blocks visible from your library' }),
+        category: core_1.Flags.string({ description: 'Only blocks in this category', options: CATEGORIES }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(InstructionBlocksList);
+        if (flags.official && flags.library) {
+            this.error('Use either --official or --library, not both.', { exit: 2 });
+        }
+        let catalog;
+        try {
+            catalog = await data_provider_1.dataService.listInstructionBlocks();
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        const all = [
+            ...(flags.library ? [] : catalog.official),
+            ...(flags.official ? [] : catalog.library),
+        ].filter((block) => !flags.category || block.category === flags.category);
+        if (flags.json) {
+            this.log(JSON.stringify({ blocks: all }, null, 2));
+            return;
+        }
+        if (!all.length) {
+            this.log('No instruction blocks match. Create one with `skrr instruction-blocks create`.');
+            return;
+        }
+        (0, format_1.renderTable)(all.map((block) => ({
+            id: block.id,
+            name: block.name,
+            source: block.source,
+            version: `v${block.currentVersion}`,
+            category: block.category,
+            summary: block.summary,
+        })), [
+            { key: 'id', header: 'ID', verbatim: true },
+            { key: 'name', header: 'NAME', maxWidth: 30 },
+            { key: 'source', header: 'SOURCE' },
+            { key: 'version', header: 'VERSION' },
+            { key: 'category', header: 'CATEGORY' },
+            { key: 'summary', header: 'SUMMARY', maxWidth: 52 },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = InstructionBlocksList;

package/dist/commands/instruction-blocks/show.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command';
+export default class InstructionBlocksShow extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: 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/instruction-blocks/show.js

@@ -0,0 +1,35 @@
+"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");
+const instruction_blocks_1 = require("../../lib/instruction-blocks");
+class InstructionBlocksShow extends base_command_1.BaseCommand {
+    static description = 'Show a reusable block, including its pinned source and requirements';
+    static examples = [
+        '<%= config.bin %> instruction-blocks show block_official_decision_memo',
+        '<%= config.bin %> instruction-blocks show block_… --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Instruction block 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(InstructionBlocksShow);
+        let block;
+        try {
+            block = await data_provider_1.dataService.getInstructionBlock(args.id);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(block, null, 2));
+            return;
+        }
+        for (const line of (0, instruction_blocks_1.renderInstructionBlockDetail)(block))
+            this.log(line);
+    }
+}
+exports.default = InstructionBlocksShow;

package/dist/commands/instruction-blocks/update.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../base-command';
+/** Any edit produces a new immutable source version; attached Agents stay pinned. */
+export default class InstructionBlocksUpdate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        summary: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        body: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        tag: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        visibility: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'parameter-schema': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        requirements: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        changelog: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/instruction-blocks/update.js

@@ -0,0 +1,94 @@
+"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");
+const instruction_blocks_1 = require("../../lib/instruction-blocks");
+const instruction_input_1 = require("../../lib/instruction-input");
+const CATEGORIES = [
+    'github',
+    'communication',
+    'research',
+    'output',
+    'planning',
+    'other',
+];
+/** Any edit produces a new immutable source version; attached Agents stay pinned. */
+class InstructionBlocksUpdate extends base_command_1.BaseCommand {
+    static description = 'Update a block you authored (creates a new immutable version; attached Agents stay pinned)';
+    static examples = [
+        '<%= config.bin %> instruction-blocks update block_… --body "Lead with evidence." --changelog "Clarify order"',
+        '<%= config.bin %> instruction-blocks update block_… --file ./review.md',
+        '<%= config.bin %> instruction-blocks update block_… --visibility workspace',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Instruction block ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        name: core_1.Flags.string({ description: 'New block name' }),
+        summary: core_1.Flags.string({ description: 'New one-line description' }),
+        body: core_1.Flags.string({ description: 'New instruction template text' }),
+        file: core_1.Flags.string({ description: 'Read new template text from a file, or - for stdin' }),
+        category: core_1.Flags.string({ description: 'New library category', options: CATEGORIES }),
+        tag: core_1.Flags.string({
+            description: 'Replace tags with these values (repeatable)',
+            multiple: true,
+        }),
+        visibility: core_1.Flags.string({ options: ['private', 'workspace', 'public'] }),
+        'parameter-schema': core_1.Flags.string({ description: 'Replace parameters with this JSON array' }),
+        requirements: core_1.Flags.string({ description: 'Replace requirements with this JSON array' }),
+        changelog: core_1.Flags.string({ description: 'Reason for this version' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(InstructionBlocksUpdate);
+        let bodyTemplate;
+        let parameterSchema;
+        let requirements;
+        try {
+            bodyTemplate = await (0, instruction_input_1.readInstructionBody)({ body: flags.body, file: flags.file });
+            parameterSchema = (0, instruction_blocks_1.parseJsonFlag)(flags['parameter-schema'], '--parameter-schema');
+            requirements = (0, instruction_blocks_1.parseJsonFlag)(flags.requirements, '--requirements');
+            if (parameterSchema && !Array.isArray(parameterSchema)) {
+                throw new Error('--parameter-schema must be a JSON array');
+            }
+            if (requirements && !Array.isArray(requirements)) {
+                throw new Error('--requirements must be a JSON array');
+            }
+        }
+        catch (error) {
+            this.error(error.message, { exit: 2 });
+        }
+        const patch = {
+            ...(flags.name !== undefined ? { name: flags.name } : {}),
+            ...(flags.summary !== undefined ? { summary: flags.summary } : {}),
+            ...(bodyTemplate !== undefined ? { bodyTemplate } : {}),
+            ...(flags.category !== undefined
+                ? { category: flags.category }
+                : {}),
+            ...(flags.tag !== undefined ? { tags: flags.tag } : {}),
+            ...(flags.visibility !== undefined
+                ? { visibility: flags.visibility }
+                : {}),
+            ...(parameterSchema !== undefined ? { parameterSchema } : {}),
+            ...(requirements !== undefined ? { requirements } : {}),
+            ...(flags.changelog !== undefined ? { changelog: flags.changelog } : {}),
+        };
+        if (!Object.keys(patch).length) {
+            this.error('Nothing to update. Pass at least one field to change.', { exit: 2 });
+        }
+        let block;
+        try {
+            block = await data_provider_1.dataService.updateInstructionBlock(args.id, patch);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(block, null, 2));
+        this.log(`Updated ${block.name} (${block.id}) to v${block.currentVersion}.`);
+        this.log('Existing Agent compositions remain pinned; upgrade them explicitly when ready.');
+    }
+}
+exports.default = InstructionBlocksUpdate;

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

@@ -1,6 +1,7 @@
 import { BaseCommand } from '../../../base-command';
 export default class SpacesAutoExecutorPreview extends BaseCommand {
     static description: string;
+    static examples: string[];
     static args: {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };

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

@@ -6,21 +6,80 @@ const base_command_1 = require("../../../base-command");
 const space_output_1 = require("../../../lib/space-output");
 class SpacesAutoExecutorPreview extends base_command_1.BaseCommand {
     static description = 'Preview what a space auto-executor run would do';
+    static examples = [
+        '<%= config.bin %> spaces auto-executor preview <space-id>',
+        '<%= config.bin %> spaces auto-executor preview <space-id> --json',
+    ];
     static args = {
         id: 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 } = await this.parse(SpacesAutoExecutorPreview);
+        // `flags` was previously not destructured at all: --json was declared,
+        // ignored, and raw JSON printed unconditionally. There was no readable
+        // rendering of a preview anywhere in the CLI.
+        const { args, flags } = await this.parse(SpacesAutoExecutorPreview);
         let result;
         try {
-            result = await data_provider_1.dataService.previewSpaceAutoExecutor(args.id);
+            result = (await data_provider_1.dataService.previewSpaceAutoExecutor(args.id));
         }
         catch (err) {
             this.handleApiError(err);
         }
-        this.log(JSON.stringify((0, space_output_1.withSpacePerspectiveUrl)(this.cliConfig.baseURL, args.id, 'execution', { result }), null, 2));
+        if (flags.json) {
+            this.log(JSON.stringify((0, space_output_1.withSpacePerspectiveUrl)(this.cliConfig.baseURL, args.id, 'execution', { result }), null, 2));
+            return;
+        }
+        const { space, plan } = result;
+        if (!plan) {
+            this.log('No plan was returned for this space.');
+            return;
+        }
+        this.log(`Space:      ${space.title ?? args.id}`);
+        this.log(`Autopilot:  ${space.autoExecuteEnabled ? 'enabled' : 'disabled'}` +
+            (space.autoExecuteLifecycleState === 'sleeping'
+                ? ` (sleeping${space.autoExecuteSuspensionReason ? `: ${String(space.autoExecuteSuspensionReason).replace(/_/g, ' ')}` : ''})`
+                : '') +
+            ` · ${plan.policy.mode}`);
+        const { capacity } = plan;
+        this.log(`Running:    ${(0, data_provider_1.formatRunningCapacity)(capacity.activeCount, capacity.maxActiveTasks)}` +
+            (capacity.maxActiveTasks === null ? ' (no concurrency cap)' : ''));
+        this.log(`Can start:  ${(0, data_provider_1.formatLimit)(capacity.startsAvailable)} now`);
+        if (capacity.budget && !capacity.budget.unlimited) {
+            this.log(`Budget:     ${capacity.budget.consumedStarts}/${capacity.budget.maxStarts} starts used this round`);
+        }
+        const { actions, summary } = plan;
+        this.log('');
+        this.log(`Board:      ${summary.readyCount} ready · ${summary.unassignedCount} unassigned · ` +
+            `${summary.runningCount} running · ${summary.failedCount} failed · ${summary.scheduledCount} scheduled`);
+        section(this.log.bind(this), 'Would start now', actions.startNow, (a) => taskLine(a.task));
+        section(this.log.bind(this), 'Would assign', actions.assignments, (a) => `${taskLine(a.task)} → ${a.suggestedAgentName ?? a.suggestedAgentId ?? 'no eligible agent'}`);
+        section(this.log.bind(this), 'Would schedule later', actions.scheduleLater, (a) => `${taskLine(a.task)} @ ${a.scheduledFor}`);
+        section(this.log.bind(this), 'Failures to review', actions.failureReviews, (a) => taskLine(a.task));
+        // The single most useful diagnostic in the payload: a ready task that is
+        // not starting because ITS agent is saturated elsewhere, not because this
+        // space is full. Without it the board just looks stuck.
+        section(this.log.bind(this), 'Waiting on agent capacity', actions.capacityWaits, (a) => `${taskLine(a.task)} (agent ${a.agentId ?? 'unknown'} is at its cross-space cap)`);
+        if (plan.risks?.length) {
+            this.log('');
+            this.log('Risks:');
+            for (const risk of plan.risks)
+                this.log(`  ! ${risk}`);
+        }
     }
 }
 exports.default = SpacesAutoExecutorPreview;
+function taskLine(task) {
+    return `${task.identifier ? `${task.identifier} ` : ''}${task.title}`;
+}
+function section(log, heading, items, render, limit = 10) {
+    if (!items?.length)
+        return;
+    log('');
+    log(`${heading} (${items.length}):`);
+    for (const item of items.slice(0, limit))
+        log(`  - ${render(item)}`);
+    if (items.length > limit)
+        log(`  … ${items.length - limit} more (use --json for all)`);
+}

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

@@ -9,7 +9,11 @@ export default class SpacesAutoExecutorUpdate extends BaseCommand {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         enabled: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'interval-ms': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cron: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'daily-time': 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>;
         'max-starts-per-run': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'max-active-tasks': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };

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

@@ -5,11 +5,21 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const prompt_1 = require("../../../lib/prompt");
 const space_output_1 = require("../../../lib/space-output");
+/**
+ * `0 = unlimited` is the persisted convention for both task limits. A flag
+ * description that omits it leaves the most useful setting undiscoverable —
+ * a user who wants "no cap" has no reason to guess that zero means it.
+ */
+const UNLIMITED_HINT = '0 = unlimited';
 class SpacesAutoExecutorUpdate extends base_command_1.BaseCommand {
     static description = 'Update a space auto-executor configuration';
     static examples = [
         '<%= config.bin %> spaces auto-executor update <space-id> --max-active-tasks 6',
         '<%= config.bin %> spaces auto-executor update <space-id> --enabled --interval-ms 600000',
+        '<%= config.bin %> spaces auto-executor update <space-id> --mode cadenced',
+        '<%= config.bin %> spaces auto-executor update <space-id> --daily-time 09:00 --daily-time 17:00 --timezone America/Vancouver',
+        '<%= config.bin %> spaces auto-executor update <space-id> --cron "0 */2 * * *"',
+        '<%= config.bin %> spaces auto-executor update <space-id> --max-starts-per-run 0   # unlimited',
         '<%= config.bin %> spaces auto-executor update <space-id> --no-enabled --json',
     ];
     static args = {
@@ -21,9 +31,28 @@ class SpacesAutoExecutorUpdate extends base_command_1.BaseCommand {
             description: 'Path to a JSON file (or "-" for stdin) to use as the patch body',
         }),
         enabled: core_1.Flags.boolean({ description: 'Enable or disable auto-execution', allowNo: true }),
-        'interval-ms': core_1.Flags.integer({ description: 'Auto-executor interval in milliseconds' }),
-        'max-starts-per-run': core_1.Flags.integer({ description: 'Max tasks to start per auto run' }),
-        'max-active-tasks': core_1.Flags.integer({ description: 'Max active task executions in this space' }),
+        mode: core_1.Flags.string({
+            description: 'continuous = a finished task promptly wakes the Leader to refill capacity; ' +
+                'cadenced = only run on the schedule, leaving a review window between batches',
+            options: [...data_provider_1.SPACE_AUTO_EXECUTION_MODES],
+        }),
+        'interval-ms': core_1.Flags.integer({
+            description: `Run every N milliseconds (min ${data_provider_1.SPACE_AUTO_EXECUTION_LIMITS.intervalMs.min}, max ${data_provider_1.SPACE_AUTO_EXECUTION_LIMITS.intervalMs.max})`,
+        }),
+        cron: core_1.Flags.string({ description: 'Run on a cron expression, e.g. "0 */2 * * *"' }),
+        'daily-time': core_1.Flags.string({
+            description: 'Run daily at HH:MM (24h). Repeatable for several times a day.',
+            multiple: true,
+        }),
+        timezone: core_1.Flags.string({
+            description: 'IANA timezone for --cron / --daily-time (default UTC)',
+        }),
+        'max-starts-per-run': core_1.Flags.integer({
+            description: `Max tasks to start per auto run (${UNLIMITED_HINT}, max ${data_provider_1.SPACE_AUTO_EXECUTION_LIMITS.maxStartsPerRun.max})`,
+        }),
+        'max-active-tasks': core_1.Flags.integer({
+            description: `Max concurrently active task executions in this space (${UNLIMITED_HINT}, max ${data_provider_1.SPACE_AUTO_EXECUTION_LIMITS.maxActiveTasks.max})`,
+        }),
     };
     async run() {
         this.requireAuth();
@@ -35,9 +64,37 @@ class SpacesAutoExecutorUpdate extends base_command_1.BaseCommand {
         catch (err) {
             this.error(err.message, { exit: 1 });
         }
+        // The API accepts exactly one recurrence shape. Rejecting here — by name,
+        // with the alternatives listed — beats a 400 that echoes the Zod refine.
+        const scheduleFlags = [
+            flags.cron !== undefined ? '--cron' : null,
+            flags['daily-time']?.length ? '--daily-time' : null,
+            flags['interval-ms'] !== undefined ? '--interval-ms' : null,
+        ].filter(Boolean);
+        if (scheduleFlags.length > 1) {
+            this.error(`Pick one schedule shape: ${scheduleFlags.join(', ')} cannot be combined.`, {
+                exit: 1,
+            });
+        }
+        const timezone = flags.timezone ? { timezone: flags.timezone } : {};
+        let schedule;
+        if (flags.cron !== undefined) {
+            schedule = { cronExpression: flags.cron, ...timezone };
+        }
+        else if (flags['daily-time']?.length) {
+            schedule = { times: flags['daily-time'], ...timezone };
+        }
+        if (flags.timezone && !schedule) {
+            this.error('--timezone applies to --cron or --daily-time; pass one of them too.', {
+                exit: 1,
+            });
+        }
         const payload = (0, prompt_1.mergeDefined)(body, {
             enabled: flags.enabled,
-            intervalMs: flags['interval-ms'],
+            mode: flags.mode,
+            // `intervalMs` and `schedule` are mutually exclusive at the API.
+            intervalMs: schedule ? undefined : flags['interval-ms'],
+            schedule,
             maxStartsPerRun: flags['max-starts-per-run'],
             maxActiveTasks: flags['max-active-tasks'],
         });
@@ -59,11 +116,25 @@ class SpacesAutoExecutorUpdate extends base_command_1.BaseCommand {
             return;
         }
         const space = response?.space ?? {};
+        // A stored `0` means unlimited. Printing the raw number told the user the
+        // opposite of what the setting does.
+        const limit = (value) => typeof value === 'number' ? (0, data_provider_1.formatLimit)(value === 0 ? null : value) : '-';
         this.log(`Updated auto-executor for ${space.id ?? args.id}`);
         this.log(`Enabled:          ${space.autoExecuteEnabled ? 'yes' : 'no'}`);
-        this.log(`Interval:         ${space.autoExecuteIntervalMs ?? '-'}`);
-        this.log(`Max starts/run:   ${space.autoExecuteMaxStartsPerRun ?? '-'}`);
-        this.log(`Max active tasks: ${space.autoExecuteMaxActiveTasks ?? '-'}`);
+        this.log(`Mode:             ${space.autoExecuteMode ?? '-'}`);
+        this.log(`Interval:         ${formatIntervalMs(space.autoExecuteIntervalMs)}`);
+        this.log(`Max starts/run:   ${limit(space.autoExecuteMaxStartsPerRun)}`);
+        this.log(`Max active tasks: ${limit(space.autoExecuteMaxActiveTasks)}`);
     }
 }
 exports.default = SpacesAutoExecutorUpdate;
+/** Milliseconds are how the field is stored, not how anyone reads a cadence. */
+function formatIntervalMs(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return '-';
+    const minutes = value / 60_000;
+    if (minutes < 60)
+        return `${minutes % 1 === 0 ? minutes : minutes.toFixed(1)}m (${value}ms)`;
+    const hours = minutes / 60;
+    return `${hours % 1 === 0 ? hours : hours.toFixed(1)}h (${value}ms)`;
+}

package/dist/commands/spaces/capacity.js

@@ -1,6 +1,7 @@
 "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");
 const format_1 = require("../../lib/format");
 const task_execution_1 = require("../../lib/task-execution");
@@ -33,11 +34,22 @@ class SpacesCapacity extends base_command_1.BaseCommand {
             return;
         }
         const space = capacity.space;
+        // `maxActiveTasks` / `availableSlots` are null when the space has no cap.
+        // Interpolating them directly is what produced `0/null active` (OSK-7087);
+        // the shared formatters in @skrr-ai/data-provider are the one place that
+        // decides how an absent ceiling reads, for the web and the CLI alike.
         this.log(`Space:      ${space.title ?? args.id}`);
         this.log(`ID:         ${space.id ?? args.id}`);
         this.log(`Auto exec:  ${space.autoExecuteEnabled ? 'enabled' : 'disabled'}`);
-        this.log(`Capacity:   ${capacity.activeCount}/${capacity.maxActiveTasks} active`);
-        this.log(`Available:  ${capacity.availableSlots}`);
+        this.log(`Capacity:   ${(0, data_provider_1.formatRunningCapacity)(capacity.activeCount, capacity.maxActiveTasks)} active` +
+            (capacity.maxActiveTasks === null ? ' (no concurrency cap)' : ''));
+        this.log(`Available:  ${(0, data_provider_1.formatLimit)(capacity.availableSlots)}`);
+        if (capacity.budget) {
+            const { consumedStarts, maxStarts, remaining, unlimited } = capacity.budget;
+            this.log(unlimited
+                ? `Starts:     ${consumedStarts} used this round (no per-run budget)`
+                : `Starts:     ${consumedStarts}/${maxStarts} used this round, ${remaining} left`);
+        }
         this.log(`Sampled:    ${capacity.sampledTaskCount} tasks`);
         if (capacity.activeTasks.length > 0) {
             this.log('');

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

@@ -20,6 +20,10 @@ export default class SpacesUpdate extends BaseCommand {
         'estimate-migration': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'default-estimate': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'use-default-estimate': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'default-expect': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'delivery-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'integration-branch': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'auto-merge-tier': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'worktree-isolation': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;