@skrr-ai/cli 0.1.36 → 0.1.37

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

@@ -0,0 +1,47 @@
+"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 TasksLifecycleAttach extends base_command_1.BaseCommand {
+    static description = 'Attach a lifecycle protocol to a Task — a built-in pack or a Space definition';
+    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static flags = {
+        pack: core_1.Flags.string({ description: "Built-in pack id, e.g. 'finding' or 'doc_to_task'" }),
+        definition: core_1.Flags.string({ description: 'WorkflowDefinition id (kind task_lifecycle)' }),
+        version: core_1.Flags.string({ description: 'Pin a specific published version id' }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleAttach);
+        const taskId = await this.resolveTaskReference(args.id);
+        if (flags.pack && flags.definition) {
+            this.error('Pass either --pack or --definition, not both.', { exit: 2 });
+        }
+        if (!flags.pack && !flags.definition) {
+            this.error('Pass --pack <id> or --definition <id>. See: tasks lifecycle definitions', {
+                exit: 2,
+            });
+        }
+        let response;
+        try {
+            response = await data_provider_1.dataService.attachTaskLifecycle({
+                taskId,
+                ...(flags.pack ? { packId: flags.pack } : {}),
+                ...(flags.definition ? { definitionId: flags.definition } : {}),
+                ...(flags.version ? { versionId: flags.version } : {}),
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        this.log(`Attached lifecycle${flags.pack ? ` pack '${flags.pack}'` : ` definition ${flags.definition}`}.`);
+        (0, task_lifecycle_output_1.renderTaskLifecycleSummary)(response, (line) => this.log(line));
+        this.log(`Start it: skrr tasks lifecycle start ${taskId}`);
+    }
+}
+exports.default = TasksLifecycleAttach;

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleDefinitions 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/definitions.js

@@ -0,0 +1,40 @@
+"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 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 flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleDefinitions);
+        const taskId = await this.resolveTaskReference(args.id);
+        let response;
+        try {
+            response = await data_provider_1.dataService.listTaskLifecycleDefinitions(taskId);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        if (response.packs.length) {
+            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 (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})` : ''}`);
+            }
+        }
+        if (!response.packs.length && !response.definitions.length) {
+            this.log('No lifecycle definitions are available to this Task.');
+        }
+    }
+}
+exports.default = TasksLifecycleDefinitions;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleDetach extends BaseCommand {
+    static description: 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,32 @@
+"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';
+    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static flags = {
+        reason: core_1.Flags.string({ description: 'Why the lifecycle is detaching' }),
+        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);
+        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));
+        this.log('Detached lifecycle from the Task.');
+    }
+}
+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,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleMigrate extends BaseCommand {
+    static description: 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,29 @@
+"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 args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static flags = {
+        version: core_1.Flags.string({ required: true, description: 'Target WorkflowDefinition version id' }),
+        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);
+        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));
+        this.log(`Migrated lifecycle — 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,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleReopen extends BaseCommand {
+    static description: 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,34 @@
+"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 args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    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' }),
+        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);
+        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));
+        this.log(`Reopened lifecycle — run ${result.run.id} (${result.run.status}).`);
+    }
+}
+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,78 @@
+"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 });
+            }
+        }
+        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;
+        }
+        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)
+            return this.log(JSON.stringify(response, null, 2));
+        (0, task_lifecycle_output_1.renderLifecycleTransitionResult)(response, (line) => this.log(line));
+    }
+}
+exports.default = TasksLifecycleTransition;

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>;
     /**

package/dist/commands/tasks/move.js

@@ -52,6 +52,9 @@ class TasksMove extends base_command_1.BaseCommand {
             description: 'Who can resolve the exceptional hold',
             options: ['human', 'agent', 'system', 'external'],
         }),
+        force: core_1.Flags.boolean({
+            description: "Close past an owner-declared required Review as a non-owner; the override is recorded on the task's resolution",
+        }),
     };
     async run() {
         this.requireAuth();
@@ -100,6 +103,7 @@ class TasksMove extends base_command_1.BaseCommand {
                             status: flags.status,
                             ...(flags.reason ? { reason: flags.reason } : {}),
                             ...(flags['resolution-actor'] ? { resolutionActor: flags['resolution-actor'] } : {}),
+                            ...(flags.force ? { force: true } : {}),
                         },
                     }));
                     updated = res.task;
@@ -110,6 +114,7 @@ class TasksMove extends base_command_1.BaseCommand {
                         status: flags.status,
                         reason: flags.reason,
                         resolutionActor: flags['resolution-actor'],
+                        force: flags.force === true ? true : undefined,
                     });
                 }
             }
@@ -138,6 +143,32 @@ class TasksMove extends base_command_1.BaseCommand {
             destinations.push(await this.describeProjectDestination(projectId, t));
         }
         this.log(`Moved task ${t.id ?? t._id ?? taskIdentity.id}${ref ? ` (${ref})` : ''} → ${destinations.join(', ')}`);
+        /*
+         * Closing is the actor's call — the server does not refuse outstanding
+         * work, it records it on `resolution.closure`. If the close just written
+         * left things unsettled, say so here so the output and the durable record
+         * tell the same story rather than letting "done" launder open items.
+         */
+        // Read through the SHARED vocabulary. This carried a local structural cast
+        // while `overrode` was missing from `Task['resolution']['closure']` — which
+        // is exactly how one surface comes to know a field the type does not. `t` is
+        // 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).`);
+            }
+        }
     }
     /**
      * Name the project the receipt lands in, resolving its title from the task's

package/dist/commands/tasks/result/submit.js

@@ -7,6 +7,7 @@ const outbox_1 = require("../../../lib/outbox");
 const task_resolver_1 = require("../../../lib/task-resolver");
 const web_url_1 = require("../../../lib/web-url");
 const api_fetch_1 = require("../../../lib/api-fetch");
+const task_closure_1 = require("../../../lib/task-closure");
 const session_task_endpoints_1 = require("../../../lib/session-task-endpoints");
 function parseJson(value, label) {
     if (!value)
@@ -126,7 +127,16 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
         const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: task.id });
         if (flags.json)
             return this.log(JSON.stringify({ ...result, url }, null, 2));
-        this.log(`Submitted Result v${result.result.version} for ${task.id}; it is ready for review.`);
+        // Say what came back, never what we hope came back.
+        //
+        // This line used to read "...; it is ready for review." unconditionally,
+        // which was false for every Task with an unassessed Expectation — and the
+        // managed instructions told the agent to read the status the call returns,
+        // which the call did not carry. Submitting a Result is not closing a Task;
+        // the response now reports where it stands and this prints exactly that.
+        this.log(`Submitted Result v${result.result.version} for ${task.id}.`);
+        for (const line of (0, task_closure_1.closureReport)(result.closure))
+            this.log(line);
         if (url)
             this.log(`Task: ${url}`);
     }

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

@@ -0,0 +1,29 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Everything in one Space that is waiting on a judgement, in one pass.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * An agent fans out. One session routinely produces nine Tasks carrying twenty
+ * or more Expectations, and every surface for settling them was built for one
+ * Task at a time — so the cost of CLOSING the work grew linearly with how well
+ * the work was DECOMPOSED, which punishes exactly the decomposition the product
+ * wants. Finding what was owed meant knowing that `tasks expectations` exists
+ * and running it per Task, having first worked out which Tasks to run it on.
+ *
+ * This is a read. It changes nothing, it names every outstanding judgement in
+ * the Space with the evidence already bound to it, and it prints the exact
+ * command that settles each one — so a reviewer can work down a list instead of
+ * reconstructing it.
+ */
+export default class TasksReviewQueue extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}