@skrr-ai/cli 0.1.119 → 0.1.120

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

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/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 : [];