@skrr-ai/cli 0.1.119 → 0.1.121

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)
  *

package/dist/commands/tasks/runs.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatRunExecutor = formatRunExecutor;
+exports.formatRunAttempt = formatRunAttempt;
+exports.formatRunAttemptState = formatRunAttemptState;
+exports.formatRunSettlement = formatRunSettlement;
+exports.formatRunCleanup = formatRunCleanup;
 exports.runNeedsFailureReason = runNeedsFailureReason;
 exports.runHandoverMarker = runHandoverMarker;
 exports.failureFromRun = failureFromRun;
@@ -33,6 +37,83 @@ function formatRunExecutor(run) {
     }
     return '-';
 }
+/**
+ * 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.
+ */
+function formatRunAttempt(ref) {
+    if (!ref || typeof ref !== 'object' || Array.isArray(ref))
+        return null;
+    const attempt = ref;
+    const kind = typeof attempt.kind === 'string' && attempt.kind.trim() ? attempt.kind : null;
+    const runId = typeof attempt.runId === 'string' && attempt.runId.trim() ? attempt.runId : null;
+    const number = typeof attempt.attempt === 'number' &&
+        Number.isSafeInteger(attempt.attempt) &&
+        attempt.attempt >= 0
+        ? String(attempt.attempt)
+        : null;
+    const generation = typeof attempt.generation === 'number' &&
+        Number.isSafeInteger(attempt.generation) &&
+        attempt.generation >= 0
+        ? String(attempt.generation)
+        : null;
+    const identity = [kind, runId].filter(Boolean).join(':');
+    const counters = [number ? `attempt ${number}` : null, generation ? `generation ${generation}` : null]
+        .filter(Boolean)
+        .join(', ');
+    return [identity || null, counters || null].filter(Boolean).join(' · ') || null;
+}
+/** The latest exact attempt is enough for a compact historical row. */
+function formatRunAttemptState(run) {
+    const terminal = formatRunAttempt(run.terminalExecutorAttemptRef);
+    const active = formatRunAttempt(run.activeExecutorAttemptRef);
+    if (terminal && active && terminal !== active)
+        return `active ${active} → terminal ${terminal}`;
+    if (terminal)
+        return `terminal ${terminal}`;
+    if (active)
+        return `active ${active}`;
+    return 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.
+ */
+function formatRunSettlement(run) {
+    const terminal = run.terminalReport;
+    const finalization = run.finalization;
+    const facts = [];
+    if (terminal?.state === 'accepted') {
+        facts.push(`terminal accepted${typeof terminal.outcome === 'string' ? ` (${terminal.outcome})` : ''}`);
+    }
+    if (finalization?.pending === true || finalization?.projected === false) {
+        facts.push('finalization pending');
+    }
+    else if (finalization?.projected === true) {
+        facts.push('finalized');
+    }
+    return facts.length ? facts.join(' · ') : null;
+}
+/**
+ * The public cleanup projection intentionally excludes reservation/fence
+ * coordinates. It is diagnostic evidence only; it never grants a CLI caller a
+ * release operation.
+ */
+function formatRunCleanup(run) {
+    const cleanup = run.cleanup;
+    const lease = cleanup?.capacityReservation;
+    if (!lease || typeof lease.state !== 'string' || !lease.state)
+        return null;
+    const reason = typeof lease.unknownReason === 'string' && lease.unknownReason
+        ? lease.unknownReason
+        : typeof lease.reason === 'string' && lease.reason
+            ? lease.reason
+            : null;
+    return `capacity ${lease.state}${reason ? ` (${reason})` : ''}`;
+}
 /**
  * Whether this run row is one whose reason the caller cannot see. (S3 dogfood finding)
  *
@@ -193,6 +274,12 @@ class TasksRuns extends base_command_1.BaseCommand {
         // The column exists only when a run carries a handover field — an older
         // deployment sends neither, and an always-on column of '-' is noise.
         const showHandover = markers.some(Boolean);
+        const attempts = items.map(formatRunAttemptState);
+        const settlements = items.map(formatRunSettlement);
+        const cleanups = items.map(formatRunCleanup);
+        const showAttempt = attempts.some(Boolean);
+        const showSettlement = settlements.some(Boolean);
+        const showCleanup = cleanups.some(Boolean);
         const rows = items.map((run, i) => ({
             runId: String(run.runId ?? run.id ?? run._id ?? '-'),
             status: String(run.status ?? '-'),
@@ -203,6 +290,9 @@ class TasksRuns extends base_command_1.BaseCommand {
             // Always present on the row so the record type stays uniform; the COLUMN
             // is what is conditional.
             handover: markers[i] ?? '-',
+            attempt: attempts[i] ?? '-',
+            settlement: settlements[i] ?? '-',
+            cleanup: cleanups[i] ?? '-',
         }));
         (0, format_1.renderTable)(rows, [
             { key: 'runId', header: 'RUN ID' },
@@ -211,6 +301,11 @@ class TasksRuns extends base_command_1.BaseCommand {
             { key: 'started', header: 'STARTED' },
             { key: 'duration', header: 'DURATION' },
             { key: 'tokens', header: 'TOKENS' },
+            ...(showAttempt ? [{ key: 'attempt', header: 'ATTEMPT', maxWidth: 48 }] : []),
+            ...(showSettlement
+                ? [{ key: 'settlement', header: 'SETTLEMENT', maxWidth: 42 }]
+                : []),
+            ...(showCleanup ? [{ key: 'cleanup', header: 'CLEANUP', maxWidth: 42 }] : []),
             ...(showHandover ? [{ key: 'handover', header: 'HANDOVER' }] : []),
         ], (line) => this.log(line));
         // Only once something failed: a healthy list pays nothing for this.

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

@@ -0,0 +1 @@
+export { default } from '../search/tasks';

package/dist/commands/tasks/search.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+// Both spellings share one implementation and result contract.
+var tasks_1 = require("../search/tasks");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(tasks_1).default; } });

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

@@ -117,6 +117,8 @@ export default class TasksShow extends BaseCommand {
         id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        fields: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        compact: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'no-enrich': import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/tasks/show.js

@@ -23,6 +23,7 @@ const principal_display_1 = require("../../lib/principal-display");
 const task_economics_line_1 = require("../../lib/task-economics-line");
 const format_1 = require("../../lib/format");
 const task_recurrence_outcome_1 = require("../../lib/task-recurrence-outcome");
+const record_output_1 = require("../../lib/record-output");
 /**
  * Where to look next — as COMMANDS, not as facts about the task.
  *
@@ -282,6 +283,8 @@ class TasksShow extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks show',
         '<%= config.bin %> tasks show --task <task-id> --json',
         '<%= config.bin %> tasks show <task-id> --json',
+        '<%= config.bin %> tasks show <task-id> --compact --json',
+        '<%= config.bin %> tasks show <task-id> --fields id,ref,title,status --json',
         '<%= config.bin %> tasks show <task-id> --no-enrich',
     ];
     static args = {
@@ -303,6 +306,7 @@ class TasksShow extends base_command_1.BaseCommand {
             description: 'How to read the description. html (default) is what is stored; markdown returns it as it was written.',
             options: ['html', 'markdown'],
         }),
+        ...record_output_1.recordOutputFlags,
     };
     async run() {
         this.requireAuth();
@@ -393,9 +397,19 @@ class TasksShow extends base_command_1.BaseCommand {
             completionRead = false;
         }
         if (flags.json) {
-            this.printJsonResult({ ...t, url, completion });
+            // `ref` is the stable copy/paste alias list output already exposes. A
+            // detail record normalizes it before any projection so callers may use
+            // `--fields ref` consistently across `tasks list` and `tasks show`.
+            const ref = (typeof t.ref === 'string' && t.ref) ||
+                (typeof t.identifier === 'string' && t.identifier) ||
+                (typeof t.taskNumber === 'number' || typeof t.taskNumber === 'string'
+                    ? `#${t.taskNumber}`
+                    : undefined);
+            this.printJsonResult((0, record_output_1.shapeRecordResponse)({ ...t, ...(ref ? { ref } : {}), ...(url ? { url } : {}), completion }, { resource: 'task', fields: flags.fields, compact: flags.compact }));
             return;
         }
+        for (const line of (0, record_output_1.textModeRecordProjectionNotes)(flags))
+            this.log(line);
         for (const line of completionLines(completion, { read: completionRead }))
             this.log(line);
         const agents = Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds : [];

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

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command';
+/** Read-only recovery for one caller-owned task-start request. */
+export default class TasksStartReceipt 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/start-receipt.js

@@ -0,0 +1,95 @@
+"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 caller-owned task-start request. */
+class TasksStartReceipt extends base_command_1.BaseCommand {
+    static description = 'Read the durable receipt for one task-start request without starting another run.';
+    static examples = [
+        '<%= config.bin %> tasks start-receipt <task-id> --request-id task-start:deploy-42',
+        '<%= config.bin %> tasks start-receipt <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' }),
+        'request-id': core_1.Flags.string({
+            description: 'The request id printed by tasks start',
+            required: true,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksStartReceipt);
+        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);
+        // The CLI may compile against a published data-provider declaration that
+        // predates this additive reader; use the runtime surface just as `start`
+        // does for its newer options.
+        const getTaskStartReceipt = data_provider_1.dataService
+            .getTaskStartReceipt;
+        let receipt;
+        try {
+            receipt = await getTaskStartReceipt(taskId, flags['request-id']);
+        }
+        catch (err) {
+            this.handleApiError(err, { subject: `Task ${taskId} start receipt` });
+        }
+        if (flags.json) {
+            this.printJsonResult(receipt);
+            return;
+        }
+        if (receipt.state === 'accepted') {
+            this.log(`Start request ${receipt.requestId} has an accepted server response.`);
+            if (receipt.responseStatus !== undefined)
+                this.log(`Response status: ${receipt.responseStatus}`);
+            if (receipt.run?.runId)
+                this.log(`Run: ${receipt.run.runId}`);
+            if (receipt.run?.autonomousRunId)
+                this.log(`Autonomous Run: ${receipt.run.autonomousRunId}`);
+            if (receipt.run?.conversationId)
+                this.log(`Conversation: ${receipt.run.conversationId}`);
+            if (receipt.run?.sessionId)
+                this.log(`Session: ${receipt.run.sessionId}`);
+            if (receipt.run?.responseMessageId) {
+                this.log(`Response message: ${receipt.run.responseMessageId}`);
+            }
+            if (receipt.code)
+                this.log(`Response code: ${receipt.code}`);
+            this.log('This receipt does not prove target acquisition, harness activity, or a terminal Task outcome.');
+            return;
+        }
+        if (receipt.state === 'pending') {
+            this.log(`Start request ${receipt.requestId} is pending; its outcome is not recorded yet.`);
+            this.log('Do not issue a fresh start. Wait for the original request or retry this exact request id.');
+            return;
+        }
+        this.log(`No task-scoped receipt exists for start request ${receipt.requestId}.`);
+        this.log(`That is not proof the start did not happen. Inspect: ${this.config.bin} tasks execution-state ${taskId}`);
+    }
+}
+exports.default = TasksStartReceipt;

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

@@ -11,7 +11,9 @@ export default class TasksStart extends BaseCommand {
         'dry-run': 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>;
         branch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }
@@ -25,6 +27,8 @@ export declare function waitingForMachine(err: unknown): {
     reason?: string;
     retryable?: boolean;
 } | null;
+/** The next safe action when admission is retained but its machine is waking. */
+export declare function waitingForMachineFollowUpLine(bin: string, taskRef: string): string;
 /**
  * What to run next, printed after a start (OSK-12128). A start used to print
  * two ids and stop, and the way to watch it was found by accident. Every