@skrr-ai/cli 0.1.119 → 0.1.121

package/dist/commands/tasks/deliverable/add.js

@@ -268,16 +268,13 @@ class TasksDeliverableAdd extends base_command_1.BaseCommand {
                     expectationIds: opts.expectationIds,
                 },
             });
+            assertArchivedDeliverableReceipt(asset);
         }
         catch (err) {
             this.handleApiError(err);
             return false;
         }
         const { resourceReceipt, ...archived } = asset;
-        if (!resourceReceipt?.link.id) {
-            this.warn('The file was archived, but this server did not return its Deliverable link. ' +
-                `Run skrr tasks deliverable list ${opts.taskId} --json to find the exact version before submitting a Result.`);
-        }
         if (opts.json) {
             // `--status` is overridden for an archived copy, and --json used to say nothing of it: the
             // receipt's observation read `available` and the requested status appeared nowhere (OSK-15437).
@@ -288,15 +285,13 @@ class TasksDeliverableAdd extends base_command_1.BaseCommand {
                 identity: opts.identity,
                 ...(notes ? { requestedStatus: opts.requestedStatus, notes: [notes] } : {}),
             }, {
-                resource: { kind: 'task_resource_link', id: resourceReceipt?.link.id },
-                task: { id: resourceReceipt?.link?.taskId },
+                resource: { kind: 'task_resource_link', id: resourceReceipt.link.id },
+                task: { id: resourceReceipt.link.taskId },
             });
             return true;
         }
-        const recorded = resourceReceipt?.link.id
-            ? `Recorded Deliverable ${resourceReceipt.link.id}: ${opts.identity}`
-            : `Archived ${opts.identity}`;
-        const version = resourceReceipt?.version.id ? `version ${resourceReceipt.version.id}; ` : '';
+        const recorded = `Recorded Deliverable ${resourceReceipt.link.id}: ${opts.identity}`;
+        const version = `version ${resourceReceipt.version.id}; `;
         this.log(`${recorded} — archived copy ${asset.id} ` +
             `(${version}sha256 pinned; observed available; self reported).`);
         const notApplied = statusNotApplied(opts.requestedStatus);
@@ -309,6 +304,21 @@ class TasksDeliverableAdd extends base_command_1.BaseCommand {
     }
 }
 exports.default = TasksDeliverableAdd;
+/** Availability and a named Resource version require the server's complete archive receipt. */
+function assertArchivedDeliverableReceipt(asset) {
+    const receipt = asset?.resourceReceipt;
+    const ids = [asset?.id, receipt?.resource?.id, receipt?.version?.id, receipt?.link?.id,
+        receipt?.observation?.id];
+    const stored = asset?.digest;
+    const versionDigest = receipt?.version?.contentDigest;
+    if (asset?.status !== 'ready' || ids.some((id) => typeof id !== 'string' || !id.trim()) ||
+        receipt?.observation?.status !== 'available' || typeof stored !== 'string' ||
+        !/^[a-f0-9]{64}$/i.test(stored) || typeof versionDigest !== 'string' ||
+        versionDigest.toLowerCase() !== `sha256:${stored.toLowerCase()}`) {
+        throw new Error('The server did not confirm a ready archived Deliverable with its exact Resource receipt. ' +
+            'Re-read the Task attachments and Deliverables before retrying.');
+    }
+}
 /** The sentence for a `--status` an archived copy overrides, or null when nothing was overridden. */
 function statusNotApplied(requestedStatus) {
     return requestedStatus && requestedStatus !== 'available'

package/dist/commands/tasks/move.js

@@ -131,6 +131,10 @@ class TasksMove extends base_command_1.BaseCommand {
                         force: flags.force === true ? true : undefined,
                     });
                 }
+                // Held for approval by the Space write policy: nothing moved, and the
+                // project change below is not sent on top of a held move.
+                if (this.reportHeldSpaceWrite(updated, { json: flags.json }))
+                    return;
             }
             if (projectId !== undefined) {
                 // Project membership is an ordinary task field — PATCH /tasks/:id.
@@ -139,6 +143,8 @@ class TasksMove extends base_command_1.BaseCommand {
                     taskId: taskRef,
                     data: { projectId },
                 });
+                if (this.reportHeldSpaceWrite(updated, { json: flags.json }))
+                    return;
             }
         }
         catch (err) {
@@ -155,7 +161,8 @@ class TasksMove extends base_command_1.BaseCommand {
         }
         if (flags.json) {
             this.printJsonOperation((0, web_url_1.withTaskUrl)(this.cliConfig.baseURL, updated), {
-                resource: { kind: 'task', id: updated?.id }, task: { id: updated?.id },
+                resource: { kind: 'task', id: updated?.id },
+                task: { id: updated?.id },
             });
             return;
         }

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

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../../base-command';
+/** Inspect one durable Task Operation without replaying it or changing execution. */
+export default class TasksOperationsShow extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'operation-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/operations/show.js

@@ -0,0 +1,98 @@
+"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_resolver_1 = require("../../../lib/task-resolver");
+/** Inspect one durable Task Operation without replaying it or changing execution. */
+class TasksOperationsShow extends base_command_1.BaseCommand {
+    static description = 'Inspect one server-authoritative Task operation by its operation ID or original request ID. Read-only; never replays work.';
+    static examples = [
+        '<%= config.bin %> tasks operations show <task-id> --operation-id opr_…',
+        '<%= config.bin %> tasks operations show <task-id> --request-id task-retry:deploy-42',
+        '<%= config.bin %> tasks operations show <task-id> --request-id task-start:deploy-42 --json',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Task ID; defaults to OVERSKY_SESSION_TASK_ID in task runtimes',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        task: core_1.Flags.string({ description: 'Task ID; overrides daemon runtime context' }),
+        'operation-id': core_1.Flags.string({ description: 'Opaque operation ID returned by the server' }),
+        'request-id': core_1.Flags.string({
+            description: 'Original start/retry request ID, when the operation response was lost',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output the full operation projection as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksOperationsShow);
+        let taskIdentity;
+        try {
+            taskIdentity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+        }
+        catch (err) {
+            const failure = (0, task_resolver_1.taskResolutionFailure)(err);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+                details: { suggestion: failure.suggestion, context: failure.details },
+            });
+        }
+        const operationId = flags['operation-id'];
+        const requestId = flags['request-id'];
+        if ((operationId && requestId) || (!operationId && !requestId)) {
+            this.error('Provide exactly one of --operation-id or --request-id.', { exit: 2 });
+        }
+        // `resolveTaskIdentity` decides which INPUT wins; it does no lookup. This
+        // turns whatever it picked into something the API can resolve — a UUID and
+        // an OSK-2423 ref pass through untouched, a title is searched.
+        const taskId = await this.resolveTaskReference(taskIdentity.id);
+        // Published CLI builds can lag the data-provider declaration during an
+        // additive rollout. The methods are still runtime functions exported by
+        // this same package, so this narrow cast preserves compatibility.
+        const service = data_provider_1.dataService;
+        let operation;
+        try {
+            operation = operationId
+                ? await service.getTaskOperation(taskId, operationId)
+                : await service.getTaskOperationByRequest(taskId, requestId);
+        }
+        catch (error) {
+            this.handleApiError(error, { subject: `Task ${taskId} operation` });
+        }
+        if (flags.json) {
+            this.printJsonResult(operation);
+            return;
+        }
+        this.log(`Operation ${operation.operationId}: ${operation.state}`);
+        this.log(`Intent: ${operation.intent}`);
+        this.log(`Phase: ${operation.phase}`);
+        if (operation.outcome)
+            this.log(`Outcome: ${operation.outcome}`);
+        this.log(`Task: ${operation.task.identifier || operation.task.id}`);
+        if (operation.task.state.workflowGeneration !== undefined) {
+            this.log(`Workflow generation: ${operation.task.state.workflowGeneration}`);
+        }
+        if (operation.receipt?.requestId)
+            this.log(`Request receipt: ${operation.receipt.requestId}`);
+        if (operation.executionReference?.runId)
+            this.log(`Execution Run: ${operation.executionReference.runId}`);
+        const attempt = operation.execution?.run.activeExecutorAttemptRef ||
+            operation.execution?.run.terminalExecutorAttemptRef;
+        if (attempt) {
+            this.log(`Executor attempt: ${attempt.kind}/${attempt.runId} #${attempt.attempt} generation ${attempt.generation}`);
+        }
+        if (operation.provenance.code)
+            this.log(`Observation: ${operation.provenance.code}`);
+        this.log(operation.recovery.disposition === 'do_not_resend'
+            ? 'This operation is not confirmed. Do not resend it; inspect the same operation or execution state.'
+            : 'This is inspect-only. Use execution-state for current execution authority.');
+    }
+}
+exports.default = TasksOperationsShow;

package/dist/commands/tasks/operations/wait.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Wait on a Task Operation's server-owned projection. This is intentionally a
+ * read-only command: it never retries, redrives, changes Task workflow, or
+ * reconstructs an action from the operation's intent.
+ */
+export default class TasksOperationsWait extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        operation: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        interval: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private printCheckpoint;
+}

package/dist/commands/tasks/operations/wait.js

@@ -0,0 +1,114 @@
+"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_resolver_1 = require("../../../lib/task-resolver");
+const task_operation_watch_1 = require("../../../lib/task-operation-watch");
+/**
+ * Wait on a Task Operation's server-owned projection. This is intentionally a
+ * read-only command: it never retries, redrives, changes Task workflow, or
+ * reconstructs an action from the operation's intent.
+ */
+class TasksOperationsWait extends base_command_1.BaseCommand {
+    static description = 'Wait read-only for one immutable Task Operation; never retries or dispatches another run';
+    static examples = [
+        '<%= config.bin %> tasks operations wait <task-id> --operation task-retry:deploy-42',
+        '<%= config.bin %> tasks operations wait <task-id> --operation task-start:deploy-42 --timeout 10m --json',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Task ID; defaults to OVERSKY_SESSION_TASK_ID in task runtimes',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        task: core_1.Flags.string({ description: 'Task ID; overrides daemon runtime context' }),
+        operation: core_1.Flags.string({ description: 'Immutable Task Operation ID to observe', required: true }),
+        interval: core_1.Flags.integer({ description: 'Polling interval in seconds', default: 5 }),
+        timeout: core_1.Flags.string({ description: 'Timeout such as 30s, 10m, 2h' }),
+        json: core_1.Flags.boolean({ description: 'Emit newline-delimited JSON operation checkpoints' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksOperationsWait);
+        let taskIdentity;
+        try {
+            taskIdentity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+        }
+        catch (error) {
+            const failure = (0, task_resolver_1.taskResolutionFailure)(error);
+            this.failWithCliError({
+                code: failure.code,
+                message: failure.message,
+                exit: 2,
+                retryable: false,
+                details: failure.suggestion ? { suggestion: failure.suggestion } : undefined,
+            });
+        }
+        const taskId = await this.resolveTaskReference(taskIdentity.id);
+        let timeoutMs;
+        try {
+            timeoutMs = (0, task_operation_watch_1.parseTaskOperationWatchDuration)(flags.timeout);
+        }
+        catch (error) {
+            this.error(error.message, { exit: 2 });
+            return;
+        }
+        const operationId = flags.operation.trim();
+        if (!operationId || operationId.length > 200) {
+            this.error('--operation must be a non-empty operation ID of at most 200 characters.', { exit: 2 });
+            return;
+        }
+        const getTaskOperation = data_provider_1.dataService.getTaskOperation;
+        if (!getTaskOperation) {
+            this.failWithCliError({
+                code: 'TASK_OPERATION_READER_UNAVAILABLE',
+                message: 'This CLI build cannot read Task Operations. Update skrr before waiting on this operation.',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        try {
+            const result = await (0, task_operation_watch_1.watchTaskOperation)({
+                taskId,
+                operationId,
+                intervalMs: Math.max(1, flags.interval) * 1000,
+                timeoutMs,
+                read: getTaskOperation,
+                onCheckpoint: (checkpoint) => this.printCheckpoint(checkpoint, Boolean(flags.json)),
+            });
+            if (result.result === 'failed')
+                this.exit(1);
+        }
+        catch (error) {
+            const candidate = error;
+            if (candidate?.code === 'TASK_OPERATION_WAIT_TIMEOUT') {
+                this.exit(124);
+                return;
+            }
+            if (candidate?.code === 'TASK_OPERATION_TERMINAL_UNKNOWN') {
+                this.failWithCliError({
+                    code: 'TASK_OPERATION_TERMINAL_UNKNOWN',
+                    message: 'The Task Operation is terminal but does not report a recognized outcome. Inspect it; do not issue a fresh operation by guesswork.',
+                    exit: 2,
+                    retryable: false,
+                    details: { taskId, operationId },
+                });
+                return;
+            }
+            this.handleApiError(error, { subject: `Task operation ${operationId}` });
+        }
+    }
+    printCheckpoint(checkpoint, json) {
+        if (json) {
+            this.log(JSON.stringify(checkpoint));
+            return;
+        }
+        if (checkpoint.changed || checkpoint.terminal || checkpoint.observation === 'timeout') {
+            this.log((0, task_operation_watch_1.taskOperationCheckpointLine)(checkpoint));
+        }
+    }
+}
+exports.default = TasksOperationsWait;

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

@@ -8,6 +8,7 @@ export default class TasksPreflight extends BaseCommand {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         skill: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        capability: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     static examples: string[];
     run(): Promise<void>;

package/dist/commands/tasks/preflight.js

@@ -14,6 +14,10 @@ class TasksPreflight extends base_command_1.BaseCommand {
         json: core_1.Flags.boolean({ description: 'Output native observations, uncertainty, and CLI verification metadata as JSON' }),
         task: core_1.Flags.string({ description: 'Task ID/ref; overrides current Task runtime context' }),
         skill: core_1.Flags.string({ description: 'Skill ID for the existing server execution preview' }),
+        capability: core_1.Flags.string({
+            multiple: true,
+            description: 'Capability required of the execution target. Repeat for every requirement.',
+        }),
     };
     static examples = [
         '<%= config.bin %> tasks preflight OSK-123',
@@ -56,7 +60,13 @@ class TasksPreflight extends base_command_1.BaseCommand {
         }
         const report = await (0, task_preflight_1.readTaskPreflight)(taskId, {
             workflow: () => data_provider_1.dataService.getTaskActionability(taskId),
-            execution: () => data_provider_1.dataService.previewTaskStart(taskId, flags.skill ? { skillId: flags.skill } : undefined),
+            execution: () => {
+                const options = {
+                    ...(flags.skill ? { skillId: flags.skill } : {}),
+                    ...(flags.capability?.length ? { requestedCapabilities: flags.capability } : {}),
+                };
+                return data_provider_1.dataService.previewTaskStart(taskId, Object.keys(options).length ? options : undefined);
+            },
         });
         // Only native diagnostic responses establish an identity for _cli; a
         // requested ref is not itself a confirmed Task record.

package/dist/commands/tasks/rearm-recurrence.js

@@ -56,6 +56,10 @@ class TasksRearmRecurrence extends base_command_1.BaseCommand {
             }, null, 2));
             return;
         }
+        if (result.pending === true) {
+            this.log(result.message);
+            return;
+        }
         const finished = result.task;
         const from = finished.identifier || finished.id || taskRef;
         const next = result.successor.identifier || result.successor.id;

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

@@ -13,10 +13,32 @@ const task_legacy_1 = require("../../../lib/task-legacy");
  */
 function describeResultDetail(current, all = []) {
     const lines = [];
+    if (current.sourceFacts?.length) {
+        lines.push('Source declarations (referenced artifacts and inferred semantics unverified):');
+        for (const receipt of current.sourceFacts) {
+            lines.push(`  ${receipt.source.id} · SHA-256 ${receipt.source.digest} · ${receipt.facts.length} declarations`);
+            for (const fact of receipt.facts)
+                lines.push(`  ${JSON.stringify(fact.pointer)}: ${JSON.stringify(fact.literal)}`);
+        }
+        lines.push('Result interpretation is reported by its submitter.');
+    }
     if (current.supersedesResultId) {
         const previous = all.find((row) => row.id === current.supersedesResultId);
         lines.push(`Supersedes: ${current.supersedesResultId}${previous ? ` (v${previous.version})` : ''}`);
     }
+    const sourceRuns = Array.from(new Set([current.runId, ...(current.sourceRunIds ?? [])].filter((runId) => typeof runId === 'string' && runId.length > 0)));
+    // A Result describes the work that produced it, not whether that work is
+    // still current after a later input. `execution-state` evaluates that latter
+    // question against the current server heads, so keep the link visible but do
+    // not manufacture an applicability claim here.
+    if (sourceRuns.length > 0)
+        lines.push(`Source run${sourceRuns.length === 1 ? '' : 's'}: ${sourceRuns.join(', ')}`);
+    const coverage = current.inputCoverage;
+    if (coverage && Number.isInteger(coverage.throughWorkInputRevision)) {
+        lines.push(`Work coverage: through input revision ${coverage.throughWorkInputRevision}` +
+            `${Number.isInteger(coverage.workflowGeneration) ? ` (generation ${coverage.workflowGeneration})` : ''}` +
+            '; current applicability is reported by tasks execution-state.');
+    }
     const links = current.resourceLinkIds ?? [];
     lines.push(`Deliverables: ${links.length > 0 ? links.join(', ') : 'none linked'}`);
     const evidence = current.evidenceRefs ?? [];

package/dist/commands/tasks/result/submit.d.ts

@@ -14,6 +14,7 @@ export default class TasksResultSubmit extends BaseCommand {
         'conclusion-json': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'structured-schema': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'structured-json': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'source-attachment': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         deliverable: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         evidence: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         attach: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;

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

@@ -37,6 +37,8 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
         'conclusion-json': core_1.Flags.string({ description: 'JSON value for the domain conclusion' }),
         'structured-schema': core_1.Flags.string({ description: 'Schema name for --structured-json' }),
         'structured-json': core_1.Flags.string({ description: 'Task-type-specific structured Result JSON' }),
+        'source-attachment': core_1.Flags.string({ multiple: true,
+            description: 'Exact Task JSON attachment ID; server records its literal declarations separately from this Result interpretation (up to four)' }),
         deliverable: core_1.Flags.string({
             multiple: true,
             description: 'Task Resource link id (repeatable)',
@@ -129,6 +131,7 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
             expectedSpecVersion: flags['spec-version'],
             runId: flags['run-id'],
             sourceRunIds: flags['source-run'],
+            sourceAttachmentIds: flags['source-attachment'],
             resourceLinkIds: flags.deliverable,
             evidenceRefs,
             remainingWork: (flags.remaining || []).map((summary) => ({ summary })),

package/dist/commands/tasks/retry-receipt.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command';
+/** Read-only recovery for one server-owned compound Task retry. */
+export default class TasksRetryReceipt extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/retry-receipt.js

@@ -0,0 +1,89 @@
+"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_resolver_1 = require("../../lib/task-resolver");
+/** Read-only recovery for one server-owned compound Task retry. */
+class TasksRetryReceipt extends base_command_1.BaseCommand {
+    static description = 'Read a task retry receipt without changing status or dispatching another run.';
+    static examples = [
+        '<%= config.bin %> tasks retry-receipt <task-id> --request-id task-retry:deploy-42',
+        '<%= config.bin %> tasks retry-receipt <task-id> --request-id task-retry:deploy-42 --json',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Task ID; defaults to OVERSKY_SESSION_TASK_ID in task runtimes',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        task: core_1.Flags.string({ description: 'Task ID; overrides daemon runtime context' }),
+        'request-id': core_1.Flags.string({
+            description: 'The request id printed by tasks retry',
+            required: true,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksRetryReceipt);
+        let taskIdentity;
+        try {
+            taskIdentity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+        }
+        catch (err) {
+            const failure = (0, task_resolver_1.taskResolutionFailure)(err);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+                details: { suggestion: failure.suggestion, context: failure.details },
+            });
+        }
+        // `resolveTaskIdentity` decides which INPUT wins; it does no lookup. This
+        // turns whatever it picked into something the API can resolve — a UUID and
+        // an OSK-2423 ref pass through untouched, a title is searched.
+        const taskId = await this.resolveTaskReference(taskIdentity.id);
+        const getTaskRetryReceipt = data_provider_1.dataService
+            .getTaskRetryReceipt;
+        let receipt;
+        try {
+            receipt = await getTaskRetryReceipt(taskId, flags['request-id']);
+        }
+        catch (err) {
+            this.handleApiError(err, { subject: `Task ${taskId} retry receipt` });
+        }
+        if (flags.json) {
+            this.printJsonResult(receipt);
+            return;
+        }
+        this.log(`Retry request ${receipt.requestId}: ${receipt.state}`);
+        if (receipt.responseStatus !== undefined)
+            this.log(`Response status: ${receipt.responseStatus}`);
+        if (receipt.statusTransition?.state) {
+            this.log(`Status transition: ${receipt.statusTransition.state}`);
+        }
+        if (receipt.statusTransition?.task?.status) {
+            this.log(`Transitioned status: ${receipt.statusTransition.task.status}`);
+        }
+        if (receipt.dispatch?.state)
+            this.log(`Dispatch: ${receipt.dispatch.state}`);
+        if (receipt.dispatch?.code)
+            this.log(`Dispatch code: ${receipt.dispatch.code}`);
+        if (receipt.dispatch?.run?.runId)
+            this.log(`Run: ${receipt.dispatch.run.runId}`);
+        if (receipt.dispatch?.run?.autonomousRunId) {
+            this.log(`Autonomous Run: ${receipt.dispatch.run.autonomousRunId}`);
+        }
+        if (receipt.dispatch?.run?.conversationId) {
+            this.log(`Conversation: ${receipt.dispatch.run.conversationId}`);
+        }
+        if (receipt.dispatch?.run?.sessionId)
+            this.log(`Session: ${receipt.dispatch.run.sessionId}`);
+        this.log('This is inspect-only. Do not resend the retry from this receipt.');
+    }
+}
+exports.default = TasksRetryReceipt;

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

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command';
+/** Explicit DRI continuation; never composes move-to-todo with a leaf start. */
+export default class TasksRetryReview extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        execute: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'run-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'expected-manifest': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/retry-review.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = require("node:crypto");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const api_fetch_1 = require("../../lib/api-fetch");
+/** Explicit DRI continuation; never composes move-to-todo with a leaf start. */
+class TasksRetryReview extends base_command_1.BaseCommand {
+    static description = 'Preview or explicitly retry exact blocked DRI review work on the same Task';
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Review Task id or ref' }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+        execute: core_1.Flags.boolean({
+            description: 'Request one fresh genuine DRI Run using the exact preview below',
+        }),
+        'run-id': core_1.Flags.string({
+            description: 'Original blocked DRI Run returned by the preview',
+            dependsOn: ['execute'],
+        }),
+        'expected-manifest': core_1.Flags.string({
+            description: 'Exact preview manifest SHA-256',
+            dependsOn: ['execute'],
+        }),
+        'request-id': core_1.Flags.string({
+            description: 'Stable request UUID; retain it when retrying an ambiguous response',
+            dependsOn: ['execute'],
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksRetryReview);
+        const taskId = await this.resolveEntityRef('task', args.id);
+        const endpoint = `/api/tasks/${encodeURIComponent(taskId)}/dri-review-retry`;
+        if (flags.execute && (!flags['run-id'] || !flags['expected-manifest'] || !flags['request-id']))
+            this.error('Execution requires --run-id, --expected-manifest and --request-id from the reviewed preview.');
+        let result;
+        try {
+            result = await (0, api_fetch_1.apiFetch)(endpoint, flags.execute
+                ? {
+                    method: 'POST',
+                    body: {
+                        runId: flags['run-id'],
+                        expectedManifest: flags['expected-manifest'],
+                        requestId: flags['request-id'],
+                    },
+                    headers: { 'X-Idempotency-Key': `dri-review-retry:${flags['request-id']}` },
+                }
+                : undefined);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.printJsonResult(result);
+        if (flags.execute) {
+            this.log(`Requested DRI review retry on ${taskId}. Request: ${result.requestId}; phase: ${result.phase}.`);
+            this.log('The server owns admission and delivery. An accepted request is not a completed Review.');
+            return;
+        }
+        this.log(JSON.stringify(result, null, 2));
+        this.log(`After reviewing the exact obligations, run: ${this.config.bin} tasks retry-review ${taskId} --execute --run-id ${result.runId} --expected-manifest ${result.manifestSha256} --request-id ${(0, node_crypto_1.randomUUID)()}`);
+    }
+}
+exports.default = TasksRetryReview;