@skrr-ai/cli 0.1.37 → 0.1.39

package/dist/commands/tasks/expectations.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const data_provider_2 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
+const data_provider_3 = require("@skrr-ai/data-provider");
 const task_closure_1 = require("../../lib/task-closure");
 /**
  * `skrr tasks expectations <task>` — what this task owes, and how far each got.
@@ -13,18 +14,21 @@ const task_closure_1 = require("../../lib/task-closure");
  * could disagree with the gate that refuses the task — and the reader would
  * have no way to tell which was lying.
  */
-const STATE_LABEL = {
-    met: 'done',
-    waived: 'dropped',
-    blocked: 'stuck',
-    // Its own word, because its next action is its own: somebody looks, rather
-    // than somebody works. Reading it as 'not yet' sends people to redo finished
-    // work, which is precisely the confusion the state was added to remove.
-    unverified: 'needs a look',
-    underway: 'on its way',
-    owed: 'not yet',
-    unassessed: 'needs assessment',
-};
+/*
+ * The labels come from `@skrr-ai/data-provider`, not from here.
+ *
+ * This file said `dropped` where the user had typed `waived` and `done` where
+ * they had typed `met`; the web said `Waived` and `Met`; and an unjudged row
+ * read as `not yet` in one column and `needs assessment` in the trailer. Three
+ * spellings of one vocabulary is how a user stops trusting that the word they
+ * wrote is the word that was stored.
+ *
+ * A state derived from a DECISION now reads back as that decision's own word.
+ * `owed` and `unassessed` stay distinct — "nobody produced it" and "nobody
+ * judged it" are different next actions — and the legend below says so, which
+ * the near-synonymous English never could on its own.
+ */
+const STATE_LABEL = data_provider_3.EXPECTATION_STATE_LABEL;
 /**
  * The evidence gap, on the rows where a reader can act on it.
  *
@@ -75,7 +79,9 @@ function evidenceGap(expectation) {
 function assessorSuffix(expectation) {
     if (!expectation.assessedByKind)
         return '';
-    if (!['met', 'waived'].includes(expectation.state))
+    // `unmet` joins them: a rejection is a judgement, and whose it was matters at
+    // least as much as whose `met` it was.
+    if (!['met', 'waived', 'unmet'].includes(expectation.state))
         return '';
     return ` (${(0, task_closure_1.describeAssessor)(expectation.assessedByKind)})`;
 }
@@ -144,9 +150,13 @@ class TasksExpectations extends base_command_1.BaseCommand {
         // "2 of 2 met" for a Task where one expectation was dropped, which is the
         // one thing a reader checking this line needs to know.
         const waived = gating.filter((e) => e.state === 'waived').length;
-        const met = gating.filter((e) => e.met).length - waived;
+        const met = gating.filter((e) => e.passed ?? e.state === 'met').length;
+        const rejected = gating.filter((e) => e.state === 'unmet').length;
         this.log('');
-        this.log(`${met} of ${gating.length} met${waived > 0 ? ` · ${waived} waived` : ''}  ·  overall: ${acceptance.state}`);
+        this.log(`${met} of ${gating.length} met` +
+            (waived > 0 ? ` · ${waived} waived` : '') +
+            (rejected > 0 ? ` · ${rejected} unmet` : '') +
+            `  ·  overall: ${acceptance.state}`);
         // Space defaults are copied into the Task at creation. `source=space`
         // remains useful provenance, but these are Task-owned Expectations now and
         // are assessed exactly like explicitly declared ones.
@@ -173,6 +183,24 @@ class TasksExpectations extends base_command_1.BaseCommand {
         if (settleable > 0) {
             this.log(`${settleable} awaiting assessment — use \`${this.config.bin} tasks expectations assess\`.`);
         }
+        /*
+         * A rejection is not an absence, and it used to read as one.
+         *
+         * `unmet` collapsed into `owed`/`unassessed`, so a reviewer's written "no"
+         * displayed as "needs assessment" — inviting someone to do the judging that
+         * had already been done, while the bulk settle skipped the row because it
+         * could see the assessment the display had hidden.
+         */
+        const rejectedRows = acceptance.expectations.filter((e) => e.state === 'unmet');
+        if (rejectedRows.length > 0) {
+            this.log(`${rejectedRows.length} judged unmet — fix the work and re-assess, or waive ` +
+                `${rejectedRows.length === 1 ? 'it' : 'them'}:`);
+            for (const row of rejectedRows) {
+                const who = row.assessedByKind ? ` by ${(0, task_closure_1.describeAssessor)(row.assessedByKind)}` : '';
+                const when = row.assessedAt ? ` on ${String(row.assessedAt).slice(0, 10)}` : '';
+                this.log(`  ${row.id}${who}${when}${row.reason ? `: ${row.reason}` : ''}`);
+            }
+        }
         // Named separately from `unjudged`, and with a different command, because
         // the two look alike on the board and are not: one needs a verdict on prose,
         // the other needs somebody to look at a thing that already exists.
@@ -217,7 +245,40 @@ class TasksExpectations extends base_command_1.BaseCommand {
         const settled = gating.filter((e) => e.met).length;
         if (gating.length > settled) {
             this.log('');
-            this.log('The current Result cannot be accepted while these Expectations remain unmet.');
+            /*
+             * Say what is OWED, not what is forbidden.
+             *
+             * This read: "The current Result cannot be accepted while these
+             * Expectations remain unmet." That gate stopped existing in `56a6ded703`
+             * — unmet Expectations are advisory, and `assertTaskMayClose` throws on
+             * exactly one code, which is not this one. The Task closes; the unmet
+             * items are stamped onto `resolution.closure`.
+             *
+             * So the sentence asserted an outcome this command never evaluated, and
+             * asserted it wrongly: an operator who believed it would go hunting for a
+             * way to force a close that needs no forcing. It is the same failure as
+             * the hard-coded "it is ready for review" that this batch removed,
+             * pointing the other way.
+             */
+            this.log(
+            // Tense-neutral on purpose: this command reads acceptance only, and
+            // fetching the Task as well — one extra round trip on every call — just
+            // to choose between "closing is allowed" and "was closed over these" is
+            // not worth it. This sentence is true before the close and after it.
+            `${gating.length - settled} Expectation(s) still owed. They do not block closing; ` +
+                'whatever is outstanding when a Task closes is recorded on `resolution.closure`.');
+        }
+        /*
+         * A legend, because two of these states are near-synonyms in English and
+         * genuinely different in what they ask of the reader.
+         */
+        const shown = new Set(acceptance.expectations.map((e) => e.state));
+        const legend = ['owed', 'unassessed', 'unmet']
+            .filter((state) => shown.has(state))
+            .map((state) => `${data_provider_3.EXPECTATION_STATE_LABEL[state]} = ${data_provider_3.EXPECTATION_STATE_HINT[state]}`);
+        if (legend.length > 1) {
+            this.log('');
+            this.log(legend.join('  ·  '));
         }
     }
 }

package/dist/commands/tasks/follow-up.js

@@ -73,8 +73,8 @@ class TasksFollowUp extends base_command_1.BaseCommand {
             description: 'Optional SLA fallback delay in seconds for event or poll_until follow-ups',
         }),
         visibility: core_1.Flags.string({
-            description: 'Whether follow-up runs silently or sends a visible message',
-            options: ['silent', 'notify'],
+            description: 'Always silent — the wake speaks only when the check finds something. Kept for compatibility; notify is not available',
+            options: ['silent'],
         }),
         priority: core_1.Flags.string({
             description: 'Follow-up task priority',

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

@@ -5,7 +5,13 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 class TasksLifecycleDefinitions extends base_command_1.BaseCommand {
     static description = 'List the lifecycle definitions and built-in packs a Task can attach';
-    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static args = {
+        id: core_1.Args.string({
+            required: true,
+            ignoreStdin: true,
+            description: 'Task ID or identifier — definitions are listed for its Space',
+        }),
+    };
     static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
     async run() {
         this.requireAuth();
@@ -24,12 +30,25 @@ class TasksLifecycleDefinitions extends base_command_1.BaseCommand {
             this.log('Built-in packs:');
             for (const pack of response.packs) {
                 this.log(`  ${pack.id} v${pack.packVersion} — ${pack.title}${pack.description ? ` — ${pack.description}` : ''}`);
+                if (pack.stageKeys?.length) {
+                    this.log(`      stages: ${pack.stageKeys.join(' → ')}`);
+                }
             }
         }
         if (response.definitions.length) {
             this.log('Space definitions:');
             for (const definition of response.definitions) {
-                this.log(`  ${definition.id} v${definition.version} — ${definition.title}${definition.packId ? ` (pack ${definition.packId})` : ''}`);
+                this.log(`  ${definition.id} v${definition.version} — ${definition.title}${definition.packId ? ` (pack ${definition.packId} v${definition.packVersion ?? '?'})` : ''}`);
+                // `attach --version` and `migrate --version` take a VERSION id, and
+                // this was the only place they could come from — and it printed the
+                // definition id and a version NUMBER, neither of which those flags
+                // accept. `migrate` was unusable without reading the API.
+                if (definition.publishedVersionId) {
+                    this.log(`      published version: ${definition.publishedVersionId}  (pass to --version)`);
+                }
+                if (definition.stageKeys?.length) {
+                    this.log(`      stages: ${definition.stageKeys.join(' → ')}`);
+                }
             }
         }
         if (!response.packs.length && !response.definitions.length) {

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

@@ -1,11 +1,18 @@
 import { BaseCommand } from '../../../base-command';
 export default class TasksLifecycleDetach extends BaseCommand {
     static description: string;
+    /**
+     * 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: string[];
     static args: {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
         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/detach.js

@@ -5,15 +5,49 @@ 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';
-    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    /**
+     * 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' }),
+        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({
@@ -26,7 +60,13 @@ class TasksLifecycleDetach extends base_command_1.BaseCommand {
         }
         if (flags.json)
             return this.log(JSON.stringify(response, null, 2));
-        this.log('Detached lifecycle from the Task.');
+        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/migrate.d.ts

@@ -1,11 +1,13 @@
 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

@@ -5,15 +5,51 @@ 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 args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    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 WorkflowDefinition version id' }),
+        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 });
@@ -23,7 +59,10 @@ class TasksLifecycleMigrate extends base_command_1.BaseCommand {
         }
         if (flags.json)
             return this.log(JSON.stringify(result, null, 2));
-        this.log(`Migrated lifecycle — run ${result.run.id} (${result.run.status}).`);
+        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/reopen.d.ts

@@ -1,12 +1,14 @@
 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

@@ -5,16 +5,50 @@ 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 args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    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' }),
+        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({
@@ -28,7 +62,10 @@ class TasksLifecycleReopen extends base_command_1.BaseCommand {
         }
         if (flags.json)
             return this.log(JSON.stringify(result, null, 2));
-        this.log(`Reopened lifecycle — run ${result.run.id} (${result.run.status}).`);
+        // 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/transition.js

@@ -42,6 +42,23 @@ class TasksLifecycleTransition extends base_command_1.BaseCommand {
                 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;
@@ -55,6 +72,10 @@ class TasksLifecycleTransition extends base_command_1.BaseCommand {
                 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;
@@ -71,8 +92,18 @@ class TasksLifecycleTransition extends base_command_1.BaseCommand {
             this.handleApiError(error);
         }
         if (flags.json)
-            return this.log(JSON.stringify(response, null, 2));
-        (0, task_lifecycle_output_1.renderLifecycleTransitionResult)(response, (line) => this.log(line));
+            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.js

@@ -5,6 +5,7 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const api_fetch_1 = require("../../lib/api-fetch");
 const session_task_endpoints_1 = require("../../lib/session-task-endpoints");
 const base_command_1 = require("../../base-command");
+const task_closure_1 = require("../../lib/task-closure");
 const web_url_1 = require("../../lib/web-url");
 const task_resolver_1 = require("../../lib/task-resolver");
 const projects_1 = require("../../lib/projects");
@@ -155,19 +156,16 @@ class TasksMove extends base_command_1.BaseCommand {
         // the loosely-typed receipt, so the narrowing cast stays; what matters is
         // that the shape it names is the one data-provider owns.
         const resolutionClosure = t.resolution?.closure;
-        if (resolutionClosure?.overrode?.includes('TASK_RESULT_REVIEW_REQUIRED')) {
-            this.log('  Closed past the owner-declared required Review — the override is recorded (resolution.closure.overrode).');
-        }
-        if (resolutionClosure?.closable === false) {
-            const parts = [];
-            const unmet = resolutionClosure.expectations?.unmet?.length ?? 0;
-            if (unmet > 0) {
-                parts.push(`${unmet} Expectation${unmet === 1 ? '' : 's'} still unmet`);
-            }
-            parts.push(...(resolutionClosure.blockers || []).filter((code) => code !== 'TASK_EXPECTATIONS_NOT_MET' && code !== 'TASK_RESULT_REVIEW_REQUIRED'));
-            if (parts.length) {
-                this.log(`  Closed over ${parts.join('; ')} (resolution.closure).`);
-            }
+        /*
+         * Through the shared renderer. This hand-rolled the rendering and pushed
+         * blocker CODES at a human — `Closed over TASK_RESULT_REQUIRED`, which is a
+         * wire identifier and, read plainly, the opposite of what just happened. The
+         * worst instance was the one this batch cares most about: a Task closed over
+         * a reviewer's objection printed `TASK_RESULT_CHANGES_REQUESTED`, rendering
+         * "somebody looked and objected" as an identifier.
+         */
+        for (const sentence of (0, task_closure_1.closureSnapshotLines)(resolutionClosure)) {
+            this.log(`  ${sentence}`);
         }
     }
     /**

package/dist/commands/tasks/review-queue.d.ts

@@ -23,7 +23,22 @@ export default class TasksReviewQueue extends BaseCommand {
         space: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         actionable: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'include-closed': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /**
+     * An empty queue must not be how you learn a Space id is wrong.
+     *
+     * A UUID-shaped ref is accepted without a lookup (`base-command` short-circuits
+     * on the SHAPE, which is a cheap and correct optimisation nearly everywhere),
+     * and the list route deliberately never 404s — an unknown Space falls back to
+     * the ACL enumeration and returns an honest empty page. Those two reasonable
+     * decisions compose into "Nothing is awaiting a judgement", exit 0, for a
+     * Space that does not exist. A typo read as done.
+     *
+     * So the existence check is paid for ONLY on the path that is about to make
+     * the completeness claim — never on the path that found work.
+     */
+    private assertSpaceExists;
 }