@skrr-ai/cli 0.1.118 → 0.1.120

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;

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

@@ -14,13 +14,9 @@ import { BaseCommand } from '../../base-command';
  * locally-running coding agent) was told an action existed and given no verb —
  * exactly the gap the CLI↔API parity contract exists to prevent.
  *
- * `retry_task` has no dedicated endpoint: it is a NAME for the documented
- * recovery, which is to return the task to a startable status and start it. So
- * this command composes the two existing endpoints rather than inventing a
- * third. The value it adds is that the advertised action is now reachable, and
- * that the status write is attached to the intent ("retry this") instead of
- * being an operator hand-editing a status field and hoping that was the right
- * one.
+ * The server owns the compound mutation. A status move and a Run admission are
+ * not independently replayable after a lost response, so the CLI sends one
+ * stable request id and offers an inspect-only receipt command for recovery.
  */
 export default class TasksRetry extends BaseCommand {
     static description: string;
@@ -31,8 +27,8 @@ export default class TasksRetry extends BaseCommand {
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'no-start': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         skill: 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.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
+const node_crypto_1 = require("node:crypto");
 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 start_1 = require("./start");
+const TASK_RETRY_REQUEST_ID_PATTERN = /^[A-Za-z0-9._:/-]{1,200}$/;
 /**
  * OSK-3815 — the CLI verb for the `retry_task` action.
  *
@@ -20,19 +21,14 @@ const start_1 = require("./start");
  * locally-running coding agent) was told an action existed and given no verb —
  * exactly the gap the CLI↔API parity contract exists to prevent.
  *
- * `retry_task` has no dedicated endpoint: it is a NAME for the documented
- * recovery, which is to return the task to a startable status and start it. So
- * this command composes the two existing endpoints rather than inventing a
- * third. The value it adds is that the advertised action is now reachable, and
- * that the status write is attached to the intent ("retry this") instead of
- * being an operator hand-editing a status field and hoping that was the right
- * one.
+ * The server owns the compound mutation. A status move and a Run admission are
+ * not independently replayable after a lost response, so the CLI sends one
+ * stable request id and offers an inspect-only receipt command for recovery.
  */
 class TasksRetry extends base_command_1.BaseCommand {
     static description = 'Retry a failed task — returns it to a startable status and starts it again (the `retry_task` action from `tasks actionability`)';
     static examples = [
         '<%= config.bin %> tasks retry <task-id>',
-        '<%= config.bin %> tasks retry <task-id> --no-start',
         '<%= config.bin %> tasks retry <task-id> --json',
     ];
     static args = {
@@ -45,12 +41,12 @@ class TasksRetry extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         task: core_1.Flags.string({ description: 'Task ID; overrides daemon runtime context' }),
-        'no-start': core_1.Flags.boolean({
-            description: 'Only clear the failed state, do not dispatch. Use when you want to edit the task before it runs again.',
-        }),
         skill: core_1.Flags.string({
             description: "Skill ID to inject into the retried run. Must be pinned to the task's space.",
         }),
+        'request-id': core_1.Flags.string({
+            description: 'Stable idempotency key for this logical retry. Reuse it only to inspect the retry receipt after a lost response.',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -70,74 +66,44 @@ class TasksRetry extends base_command_1.BaseCommand {
             });
         }
         const taskRef = await this.resolveEntityRef('task', taskIdentity.id);
-        // Step 1 — clear the terminal state. `todo` rather than `backlog`: the task
-        // was already triaged into the working set once, and a retry is not a
-        // decision to deprioritise it.
-        let movedTask;
-        try {
-            movedTask = await data_provider_1.dataService.moveTask({
-                taskId: taskRef,
-                status: 'todo',
-            });
-        }
-        catch (err) {
-            this.handleApiError(err, { subject: `Task ${taskRef}` });
-        }
-        // This receipt describes the first committed transition. Dispatch may
-        // change the Task again, so it is not an overall current-state snapshot.
-        const statusTransition = { requestedStatus: 'todo', task: movedTask };
-        if (flags['no-start']) {
-            if (flags.json) {
-                this.log(JSON.stringify({
-                    taskId: taskRef,
-                    status: movedTask?.status,
-                    started: false,
-                    statusTransition,
-                }));
-                return;
-            }
-            this.log(`Cleared failed state on ${taskRef}; execution was not requested.`);
-            if (typeof movedTask?.status === 'string')
-                this.log(`Status: ${movedTask.status}`);
-            this.log(`Start it with: ${this.config.bin} tasks start ${taskRef}`);
-            return;
+        if (flags['request-id'] !== undefined &&
+            !TASK_RETRY_REQUEST_ID_PATTERN.test(flags['request-id'])) {
+            this.error('--request-id must be 1-200 characters of letters, digits and . _ : / - (it is sent as an idempotency key).', { exit: 2 });
         }
+        const requestId = flags['request-id'] || `task-retry:${(0, node_crypto_1.randomUUID)()}`;
         let result;
         try {
-            result = await data_provider_1.dataService.startTask(taskRef, flags.skill ? { skillId: flags.skill } : undefined);
+            result = await data_provider_1.dataService.retryTask(taskRef, { requestId, ...(flags.skill ? { skillId: flags.skill } : {}) });
         }
         catch (err) {
-            const waiting = (0, start_1.waitingForMachine)(err);
-            if (waiting) {
-                if (flags.json) {
-                    this.log(JSON.stringify({
-                        waiting: true,
-                        code: 'TASK_WAITING_FOR_MACHINE',
-                        taskId: taskRef,
-                        started: false,
-                        statusTransition,
-                        ...waiting,
-                    }, null, 2));
-                    return;
-                }
-                this.log(`Task ${taskRef} is waiting for the machine to start; the task will run by itself once it is ready.`);
-                if (waiting.message)
-                    this.log(waiting.message);
-                return;
-            }
-            const observedStatus = typeof movedTask?.status === 'string' ? ` (returned status '${movedTask.status}')` : '';
             this.handleApiError(err, {
-                subject: `Task ${taskRef} (status transition committed${observedStatus}; start was not confirmed. ` +
-                    `Check ${this.config.bin} tasks show ${taskRef}, then use ${this.config.bin} tasks start ${taskRef} if needed)`,
+                subject: `Task ${taskRef} retry was not confirmed. Inspect ${this.config.bin} tasks retry-receipt ` +
+                    `${taskRef} --request-id ${requestId}; do not issue a new retry id by guesswork.`,
             });
         }
         if (flags.json) {
-            this.log(JSON.stringify({ ...result, taskId: taskRef, started: true, statusTransition }, null, 2));
+            this.log(JSON.stringify({ ...result, taskId: taskRef, requestId }, null, 2));
+            return;
+        }
+        if (!result.started) {
+            this.log(`Retry request ${requestId} is ${result.state}; dispatch is not confirmed.`);
+            if (result.dispatch?.code)
+                this.log(`Dispatch code: ${result.dispatch.code}`);
+            this.log(`Inspect only: ${this.config.bin} tasks retry-receipt ${taskRef} --request-id ${requestId}`);
             return;
         }
         this.log(`Retried task ${taskRef}`);
-        this.log(`Conversation: ${result.conversationId}`);
-        this.log(`Session:      ${result.sessionId}`);
+        this.log(`Retry receipt: ${requestId}`);
+        if (result.runId)
+            this.log(`Run:          ${result.runId}`);
+        if (result.autonomousRunId)
+            this.log(`Autonomous Run: ${result.autonomousRunId}`);
+        if (result.conversationId)
+            this.log(`Conversation: ${result.conversationId}`);
+        if (result.sessionId)
+            this.log(`Session:      ${result.sessionId}`);
+        if (result.responseMessageId)
+            this.log(`Response message: ${result.responseMessageId}`);
     }
 }
 exports.default = TasksRetry;

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

@@ -6,6 +6,27 @@ import { type RunFailure } from './activity';
  * daemon id was not recorded). `-` when the row predates executor stamping.
  */
 export declare function formatRunExecutor(run: Record<string, unknown>): string;
+/**
+ * The executor attempt is the recovery fence, not a coordinator or terminal
+ * identity.  Keep it in the Task run listing because it lets a person tell a
+ * current retry from an old report without requiring them to discover an
+ * executor-specific UI.
+ */
+export declare function formatRunAttempt(ref: unknown): string | null;
+/** The latest exact attempt is enough for a compact historical row. */
+export declare function formatRunAttemptState(run: Record<string, unknown>): string | null;
+/**
+ * A terminal report, Task finalization and resource cleanup are deliberately
+ * separate receipts. This compact text preserves that order instead of calling
+ * any one of them "done" for the whole Task.
+ */
+export declare function formatRunSettlement(run: Record<string, unknown>): string | null;
+/**
+ * The public cleanup projection intentionally excludes reservation/fence
+ * coordinates. It is diagnostic evidence only; it never grants a CLI caller a
+ * release operation.
+ */
+export declare function formatRunCleanup(run: Record<string, unknown>): string | null;
 /**
  * Whether this run row is one whose reason the caller cannot see. (S3 dogfood finding)
  *