@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/tasks/lifecycle/detach.js

@@ -0,0 +1,72 @@
+"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");
+class TasksLifecycleDetach extends base_command_1.BaseCommand {
+    static description = 'Detach the lifecycle from a Task — fences the generation, leaves the run as history';
+    /**
+     * oclif prints `description` in help and nothing else, so a one-liner that
+     * repeats the summary tells a reader nothing about an operation that is not
+     * obviously reversible. Say what it does to each thing it touches.
+     */
+    static examples = [
+        '<%= config.bin %> tasks lifecycle detach OSK-1234 --dry-run',
+        '<%= config.bin %> tasks lifecycle detach OSK-1234 --reason "Wrong protocol for this work"',
+    ];
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Task ID or identifier' }),
+    };
+    static flags = {
+        reason: core_1.Flags.string({ description: 'Why the lifecycle is detaching; recorded in history' }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Describe what detaching would do and exit without writing',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleDetach);
+        const taskId = await this.resolveTaskReference(args.id);
+        if (flags['dry-run']) {
+            let current;
+            try {
+                current = await data_provider_1.dataService.getTaskLifecycle(taskId);
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (flags.json)
+                return this.log(JSON.stringify({ dryRun: true, ...current }, null, 2));
+            const lifecycle = current.lifecycle;
+            if (!lifecycle)
+                return this.log('No lifecycle is attached to this Task — nothing to detach.');
+            this.log(`Would detach ${lifecycle.packId ? `pack ${lifecycle.packId}` : `definition ${lifecycle.definitionId}`}` +
+                ` at generation ${lifecycle.generation}, stage ${lifecycle.currentStageKey ?? '—'}.`);
+            this.log('  The run is cancelled and kept as history; nothing already recorded is removed.');
+            this.log('  The generation is bumped, so no in-flight writer from the old run can land.');
+            this.log('  Re-attaching afterwards starts a NEW generation — it does not resume this one.');
+            return;
+        }
+        let response;
+        try {
+            response = await data_provider_1.dataService.detachTaskLifecycle({
+                taskId,
+                ...(flags.reason ? { reason: flags.reason } : {}),
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        const lifecycle = response.lifecycle;
+        // Name what changed. "Detached lifecycle from the Task." left the reader to
+        // diff the state afterwards to learn what had happened.
+        this.log(`Detached${lifecycle?.packId ? ` pack ${lifecycle.packId}` : ''} — the run is cancelled and` +
+            ` kept as history, and the binding is now generation ${lifecycle?.generation ?? '?'}` +
+            ` (${lifecycle?.status ?? 'detached'}).`);
+        this.log('Re-attach with: skrr tasks lifecycle attach <task-id> --pack <pack>');
+    }
+}
+exports.default = TasksLifecycleDetach;

package/dist/commands/tasks/lifecycle/history.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleHistory extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        before: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/lifecycle/history.js

@@ -0,0 +1,38 @@
+"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 task_lifecycle_output_1 = require("../../../lib/task-lifecycle-output");
+class TasksLifecycleHistory extends base_command_1.BaseCommand {
+    static description = 'Show the durable lifecycle event stream for a Task — every generation, newest first';
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Task ID' }),
+    };
+    static flags = {
+        limit: core_1.Flags.integer({ min: 1, max: 200, description: 'Maximum events to return (1-200)' }),
+        before: core_1.Flags.string({
+            description: 'ISO timestamp — only events recorded before it (pagination)',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleHistory);
+        const taskId = await this.resolveTaskReference(args.id);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getTaskLifecycleHistory(taskId, {
+                limit: flags.limit,
+                before: flags.before,
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        (0, task_lifecycle_output_1.renderLifecycleHistory)(response, (line) => this.log(line));
+    }
+}
+exports.default = TasksLifecycleHistory;

package/dist/commands/tasks/lifecycle/migrate.d.ts

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

package/dist/commands/tasks/lifecycle/migrate.js

@@ -0,0 +1,68 @@
+"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");
+class TasksLifecycleMigrate extends base_command_1.BaseCommand {
+    static description = 'Migrate a bound lifecycle to a newer published version, fencing the old generation';
+    static examples = [
+        '<%= config.bin %> tasks lifecycle definitions OSK-1234   # where a --version comes from',
+        '<%= config.bin %> tasks lifecycle migrate OSK-1234 --version wfv_… --dry-run',
+    ];
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Task ID or identifier' }),
+    };
+    static flags = {
+        version: core_1.Flags.string({
+            required: true,
+            description: 'Target published version id — `tasks lifecycle definitions <task-id>` prints it',
+        }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Describe what migrating would do and exit without writing',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleMigrate);
+        const taskId = await this.resolveTaskReference(args.id);
+        // Moving a Task between published protocols is not obviously reversible,
+        // and the old output said only that a run had started. A flag rather than a
+        // prompt, so the command stays usable from a script.
+        if (flags['dry-run']) {
+            let current;
+            try {
+                current = await data_provider_1.dataService.getTaskLifecycle(taskId);
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (flags.json)
+                return this.log(JSON.stringify({ dryRun: true, ...current }, null, 2));
+            const lifecycle = current.lifecycle;
+            if (!lifecycle)
+                return this.log('No lifecycle is attached to this Task — nothing to migrate.');
+            this.log(`Would migrate from version ${lifecycle.versionId} to ${flags.version}, as generation ` +
+                `${Number(lifecycle.generation) + 1}.`);
+            this.log(`  It re-enters at the CURRENT stage (${lifecycle.currentStageKey ?? '—'}) when that stage` +
+                " still exists on the target version; otherwise the protocol's entry stage decides.");
+            this.log('  The old generation is fenced — its run can no longer write.');
+            this.log('  Earlier generations stay readable in `tasks lifecycle history`.');
+            return;
+        }
+        let result;
+        try {
+            result = await data_provider_1.dataService.migrateTaskLifecycle({ taskId, versionId: flags.version });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        const lifecycle = result.lifecycle;
+        this.log(`Migrated to version ${lifecycle?.versionId ?? flags.version} — now generation ` +
+            `${lifecycle?.generation ?? '?'} at stage ${lifecycle?.currentStageKey ?? '—'}` +
+            ` (run ${result.run.id}, ${result.run.status}).`);
+    }
+}
+exports.default = TasksLifecycleMigrate;

package/dist/commands/tasks/lifecycle/reconcile.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleReconcile extends BaseCommand {
+    static description: 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/tasks/lifecycle/reconcile.js

@@ -0,0 +1,27 @@
+"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 task_lifecycle_output_1 = require("../../../lib/task-lifecycle-output");
+class TasksLifecycleReconcile extends base_command_1.BaseCommand {
+    static description = 'Re-sync the Task lifecycle projection with the authoritative Workflow run';
+    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleReconcile);
+        const taskId = await this.resolveTaskReference(args.id);
+        let response;
+        try {
+            response = await data_provider_1.dataService.reconcileTaskLifecycle(taskId);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        (0, task_lifecycle_output_1.renderTaskLifecycleSummary)(response, (line) => this.log(line));
+    }
+}
+exports.default = TasksLifecycleReconcile;

package/dist/commands/tasks/lifecycle/reopen.d.ts

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

package/dist/commands/tasks/lifecycle/reopen.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");
+class TasksLifecycleReopen extends base_command_1.BaseCommand {
+    static description = 'Fence the current lifecycle generation and reopen at an earlier stage';
+    static examples = [
+        '<%= config.bin %> tasks lifecycle reopen OSK-1234 --dry-run',
+        '<%= config.bin %> tasks lifecycle reopen OSK-1234 --stage fix --reason "The fix did not take"',
+    ];
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Task ID or identifier' }),
+    };
+    static flags = {
+        stage: core_1.Flags.string({ description: 'Stage key to re-enter at; defaults to the entry stage' }),
+        reason: core_1.Flags.string({ description: 'Why the lifecycle is reopening; recorded in history' }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Describe what reopening would do and exit without writing',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleReopen);
+        const taskId = await this.resolveTaskReference(args.id);
+        // Reopen advances a generation and is not obviously reversible. A preview
+        // that names the target stage is cheaper than learning what it did by
+        // diffing state afterwards, and a flag keeps the command scriptable where
+        // an interactive prompt would not.
+        if (flags['dry-run']) {
+            let current;
+            try {
+                current = await data_provider_1.dataService.getTaskLifecycle(taskId);
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (flags.json)
+                return this.log(JSON.stringify({ dryRun: true, ...current }, null, 2));
+            const lifecycle = current.lifecycle;
+            if (!lifecycle)
+                return this.log('No lifecycle is attached to this Task — nothing to reopen.');
+            const entry = flags.stage || current.stages?.[0]?.key;
+            this.log(`Would reopen at stage ${entry ?? '(entry stage)'} as generation ${Number(lifecycle.generation) + 1}` +
+                ` (currently generation ${lifecycle.generation}, stage ${lifecycle.currentStageKey ?? '—'}).`);
+            this.log('  The current run is cancelled; its transitions stay readable in history.');
+            this.log("  A terminal Task is brought back to the entry stage's declared status.");
+            this.log('  Stages the earlier generation finished keep reading as done in that generation.');
+            return;
+        }
+        let result;
+        try {
+            result = await data_provider_1.dataService.reopenTaskLifecycle({
+                taskId,
+                ...(flags.stage ? { stageKey: flags.stage } : {}),
+                ...(flags.reason ? { reason: flags.reason } : {}),
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        // Name where it landed, not just that it happened.
+        const lifecycle = result.lifecycle;
+        this.log(`Reopened at stage ${lifecycle?.currentStageKey ?? '—'} as generation ${lifecycle?.generation ?? '?'}` +
+            ` — run ${result.run.id} (${result.run.status}). The previous generation stays in history.`);
+    }
+}
+exports.default = TasksLifecycleReopen;

package/dist/commands/tasks/lifecycle/show.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleShow extends BaseCommand {
+    static description: 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/tasks/lifecycle/show.js

@@ -0,0 +1,27 @@
+"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 task_lifecycle_output_1 = require("../../../lib/task-lifecycle-output");
+class TasksLifecycleShow extends base_command_1.BaseCommand {
+    static description = 'Show the Task Lifecycle bound to a Task — stages, position, and legal transitions';
+    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleShow);
+        const taskId = await this.resolveTaskReference(args.id);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getTaskLifecycle(taskId);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        (0, task_lifecycle_output_1.renderTaskLifecycleSummary)(response, (line) => this.log(line));
+    }
+}
+exports.default = TasksLifecycleShow;

package/dist/commands/tasks/lifecycle/start.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleStart extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'start-identity': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/lifecycle/start.js

@@ -0,0 +1,30 @@
+"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");
+class TasksLifecycleStart extends base_command_1.BaseCommand {
+    static description = 'Start the lifecycle run bound to a Task';
+    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static flags = {
+        'start-identity': core_1.Flags.string({ description: 'Idempotency identity for this logical start' }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleStart);
+        const taskId = await this.resolveTaskReference(args.id);
+        let result;
+        try {
+            result = await data_provider_1.dataService.startTaskLifecycle(taskId, flags['start-identity']);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        this.log(`${result.reused ? 'Opened' : 'Started'} lifecycle run ${result.run.id} (${result.run.status}).`);
+        this.log(`Inspect: skrr tasks lifecycle show ${taskId}`);
+    }
+}
+exports.default = TasksLifecycleStart;

package/dist/commands/tasks/lifecycle/transition.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleTransition extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        transition: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        payload: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'idempotency-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'expected-revision': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/lifecycle/transition.js

@@ -0,0 +1,109 @@
+"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 task_lifecycle_output_1 = require("../../../lib/task-lifecycle-output");
+class TasksLifecycleTransition extends base_command_1.BaseCommand {
+    static description = 'Apply a declared lifecycle transition — records effects and advances the stage';
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Task ID' }),
+        transition: core_1.Args.string({
+            required: true,
+            ignoreStdin: true,
+            description: 'Transition id declared by the waiting stage',
+        }),
+    };
+    static flags = {
+        payload: core_1.Flags.string({
+            description: 'JSON payload the transition requires (fields, evidence, refs)',
+        }),
+        'idempotency-key': core_1.Flags.string({
+            description: 'Stable key for safe retries; defaults to a per-revision key derived from the Task and transition',
+        }),
+        'expected-revision': core_1.Flags.integer({
+            description: 'Optimistic CAS fence; defaults to the current lifecycle revision',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleTransition);
+        const taskId = await this.resolveTaskReference(args.id);
+        let payload;
+        if (flags.payload) {
+            try {
+                payload = JSON.parse(flags.payload);
+            }
+            catch {
+                this.error('--payload must be valid JSON.', { exit: 2 });
+            }
+            if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+                this.error('--payload must be a JSON object.', { exit: 2 });
+            }
+        }
+        /*
+         * The fence only protects the interval it is given.
+         *
+         * `--expected-revision` is the caller's claim about the state they DECIDED
+         * against. When it is omitted this command re-reads the lifecycle and sends
+         * back what it just read — and a compare-and-set whose expected value was
+         * fetched microseconds before the write can only catch that microsecond,
+         * never the interval that matters, which is between the human's read and
+         * their write. So the default is a convenience, not protection, and it was
+         * silent about that: a `confirm` decided at revision 0 applied against
+         * revision 1 and closed a Task, with nothing in the output saying the world
+         * had moved in between.
+         *
+         * Kept as the default because requiring a number on every call would be
+         * paid by everyone to protect a minority of flows — but it now says what it
+         * fenced on and how to fence properly.
+         */
+        let expectedRevision = flags['expected-revision'];
+        if (expectedRevision === undefined) {
+            let current;
+            try {
+                current = await data_provider_1.dataService.getTaskLifecycle(taskId);
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (!current.lifecycle) {
+                this.error('No lifecycle is attached to this Task.', { exit: 2 });
+            }
+            expectedRevision = current.lifecycle.revision;
+            if (!flags.json) {
+                this.log(`Fencing on revision ${expectedRevision}, read just now — not the revision you saw. ` +
+                    'Pass --expected-revision <n> to fence on the state you decided against.');
+            }
+        }
+        const idempotencyKey = flags['idempotency-key'] ?? `cli-lifecycle:${taskId}:${args.transition}:r${expectedRevision}`;
+        let response;
+        try {
+            response = await data_provider_1.dataService.transitionTaskLifecycle({
+                taskId,
+                transitionId: args.transition,
+                idempotencyKey,
+                expectedRevision,
+                ...(payload ? { payload } : {}),
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            this.log(JSON.stringify(response, null, 2));
+        else
+            (0, task_lifecycle_output_1.renderLifecycleTransitionResult)(response, (line) => this.log(line));
+        // Exit non-zero when the write did not land. `applied` is the only verdict
+        // that means the stage moved; `rejected`, `superseded` and `gated` all mean
+        // it did not. Exiting 0 on all four made
+        // `transition A && transition B` run B after A had been fenced off — which
+        // is precisely the lost update `expectedRevision` exists to prevent, waved
+        // through by the shell.
+        if (response.status !== 'applied') {
+            this.exit(1);
+        }
+    }
+}
+exports.default = TasksLifecycleTransition;

package/dist/commands/tasks/list.js

@@ -146,13 +146,13 @@ function buildListParams(flags, assigneeUserId) {
         ...(flag('actionability-reason')
             ? { actionabilityReason: flag('actionability-reason') }
             : {}),
-        ...(flag('actionable-by') ||
-            flag('actionable-for-agent') ||
-            flag('needs-me') ||
-            flag('actionability-state') ||
-            flag('actionability-reason')
-            ? { includeActionability: true }
-            : {}),
+        // This table always renders a NEXT column, so it always has to ask for the
+        // data behind it. Requesting it only alongside an actionability FILTER left
+        // the default board printing a header with nothing under it — and a plain
+        // `tasks list` is exactly where a person looks to find out what anything is
+        // waiting for. The server computes it in one batched read, so the cost is
+        // a column that works rather than a column that is there.
+        includeActionability: true,
         ...(flag('priority') ? { priority: flag('priority') } : {}),
         ...(flag('estimate') !== undefined ? { estimate: flag('estimate') } : {}),
         ...(flag('min-estimate') !== undefined
@@ -427,8 +427,13 @@ class TasksList extends base_command_1.BaseCommand {
                 priority: String(t.priority ?? '-'),
                 estimate: t.estimate === null || t.estimate === undefined ? '-' : String(t.estimate),
                 assignees,
+                // `reason` is the sentence the server wrote for a person; `reasonCode`
+                // is the enum it wrote for a machine. Printing the code rendered every
+                // stage of every lifecycle as `human:lifecycle_stage` — six different
+                // waits, one string — while the sentence naming the stage sat unread in
+                // the same payload.
                 next: actionability
-                    ? `${String(actionability.nextActor ?? '-')}:${String(actionability.reasonCode ?? actionability.state ?? '-')}`
+                    ? `${String(actionability.nextActor ?? '-')}: ${String(actionability.reason || actionability.reasonCode || actionability.state || '-')}`
                     : String(t.executionMode ?? '-'),
                 match: String(t._matchField ?? '-'),
             };
@@ -440,7 +445,9 @@ class TasksList extends base_command_1.BaseCommand {
             { key: 'priority', header: 'PRIORITY' },
             { key: 'estimate', header: 'ESTIMATE' },
             { key: 'assignees', header: 'ASSIGNEES' },
-            { key: 'next', header: 'NEXT' },
+            // Bounded: the reason is a sentence, and an unbounded column wraps the
+            // table into unreadability on a narrow terminal.
+            { key: 'next', header: 'NEXT', maxWidth: 46 },
             // Only meaningful on a search — the server computes it from the same
             // relevance rank that orders the rows, and a plain listing has none.
             ...(flags.q ? [{ key: 'match', header: 'MATCH' }] : []),

package/dist/commands/tasks/move.d.ts

@@ -21,6 +21,7 @@ export default class TasksMove extends BaseCommand {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'resolution-actor': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     /**