@sanity/workflow-cli 0.31.0 → 0.33.0

package/dist/commands/workflows/diagnose.js

@@ -1,13 +1,15 @@
 import { styleText } from 'node:util';
 import { Args } from '@oclif/core';
+import { formatDateTime } from '@sanity/cli-core/dates';
 import { diagnoseInputFromEvaluation, workflow, unsatisfiedTransitionSummaries, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
 import { WorkflowCommand } from "../../lib/base-command.js";
+import { stuckDiagnosisLines, stuckHeadline } from "../../lib/cause-detail.js";
 import { resolveInstanceContext } from "../../lib/context.js";
 import { fail, failureDetail } from "../../lib/fail.js";
 import { instanceFlags, jsonFlags } from "../../lib/flags.js";
 import { baseEngineArgs } from "../../lib/operation-args.js";
-import { formatTimestamp, sectionHeader, activityIcon } from "../../lib/ui.js";
+import { sectionHeader, activityIcon } from "../../lib/ui.js";
 import { instanceHeader } from "./show.js";
 function formatAssignee(a) {
     return a.type === 'user' ? `user:${a.id}` : `role:${a.role}`;
@@ -39,57 +41,32 @@ function currentStageLines(input, explanations) {
     }
     return lines;
 }
-function failedEffectDetail(effect) {
-    const ran = effect.durationMs !== undefined ? ` (after ${effect.durationMs}ms)` : '';
-    return {
-        headline: `a failed effect from action '${effect.origin.name}' is blocking its activity`,
-        why: [
-            styleText('red', `${logSymbols.error} failed effect: ${effect.name}`),
-            `  queued by action '${effect.origin.name}', failed ${formatTimestamp(effect.ranAt)}${ran}`,
-            ...(effect.error !== undefined ? [`  error: ${effect.error.message}`] : []),
-            '',
-            `The activity that fired '${effect.origin.name}' is waiting on this effect. It failed`,
-            `against an external system, so the activity never resolves and the stage can't advance.`,
-        ],
-    };
-}
-function hungEffectDetail(effect) {
-    return {
-        headline: `effect '${effect.name}' was claimed but never completed`,
-        why: [
-            styleText('yellow', `${logSymbols.warning} hung effect: ${effect.name}`),
-            `  claimed ${formatTimestamp(effect.claim?.claimedAt ?? '?')} but never reported back — the`,
-            `  drainer likely died mid-dispatch, so it won't drain on its own.`,
-        ],
-    };
-}
-function failedActivityDetail(activity) {
-    return {
-        headline: `activity '${activity}' failed`,
-        why: [
-            styleText('red', `${logSymbols.error} activity '${activity}' is in a terminal failed state.`),
-            `Any exit transition gated on '${activity}' being done can never fire.`,
-        ],
-    };
-}
 function waitingHeadline(w) {
     const who = w.assignees.length > 0 ? ` on ${w.assignees.map(formatAssignee).join(', ')}` : '';
-    if (w.actions.length === 0) {
+    if (w.waitingFor === 'automation') {
         return `waiting${who} on automation — a trigger fires on its own when its condition holds`;
     }
+    if (w.waitingFor === 'manual-action')
+        return `waiting${who} for an eligible caller to act`;
     return `waiting${who} for action: ${w.actions.join(' or ')}`;
 }
 function waitingLines(w) {
     const who = w.assignees.length > 0
         ? `assigned to ${w.assignees.map(formatAssignee).join(', ')}`
-        : 'unassigned — anyone with permission can act';
-    if (w.actions.length === 0) {
+        : 'unassigned — no holder is selected';
+    if (w.waitingFor === 'automation') {
         return [
             `${logSymbols.info} activity '${w.activity}' is active (${who}),`,
             `waiting on automation: its cascade-fired action(s) fire on their own when their`,
             `trigger conditions hold — nothing for a caller to fire.`,
         ];
     }
+    if (w.waitingFor === 'manual-action') {
+        return [
+            `${logSymbols.info} activity '${w.activity}' is active (${who}),`,
+            `waiting for a manual action, but none is available to this caller right now.`,
+        ];
+    }
     return [
         `${logSymbols.info} activity '${w.activity}' is active (${who}),`,
         `waiting for action: ${w.actions.join(' or ')}. This is the normal in-flight`,
@@ -111,44 +88,6 @@ function blockedLines(b) {
         `activity completing, required content landing). It will not advance on its own.`,
     ];
 }
-function noTransitionDetail() {
-    return {
-        headline: `no exit transition's trigger is satisfied`,
-        why: [
-            `${logSymbols.info} every activity is resolved, but no exit transition's \`when\` is true.`,
-            `Likely a routing state value a trigger reads never got written.`,
-        ],
-    };
-}
-function transitionUnevaluableDetail(transitions) {
-    return {
-        headline: `an exit transition's trigger could not be evaluated`,
-        why: [
-            `${logSymbols.info} every activity is resolved, but ${transitions.join(', ')} reads an operand`,
-            `that is missing or unreadable (GROQ null), so routing is held rather than`,
-            `falling through. Make the data the trigger reads readable — publish the`,
-            `subject (or fill the field) — and the instance advances on its own; no`,
-            `set-stage needed.`,
-        ],
-    };
-}
-function remediationLines(remediations) {
-    return remediations.map((r) => `  • ${r.verb} — ${r.rationale}`);
-}
-function causeDetail(cause) {
-    switch (cause.kind) {
-        case 'failed-effect':
-            return failedEffectDetail(cause.effect);
-        case 'hung-effect':
-            return hungEffectDetail(cause.effect);
-        case 'failed-activity':
-            return failedActivityDetail(cause.activity);
-        case 'no-transition-fires':
-            return noTransitionDetail();
-        case 'transition-unevaluable':
-            return transitionUnevaluableDetail(cause.transitions);
-    }
-}
 function liveChildrenTail(diagnosis) {
     if (diagnosis.liveChildren === undefined)
         return '';
@@ -163,13 +102,13 @@ function statusLine(diagnosis) {
         case 'blocked':
             return `${logSymbols.info} ${styleText('cyan', 'blocked')} — ${blockedHeadline(diagnosis)}`;
         case 'completed':
-            return `${logSymbols.success} ${styleText('green', 'completed')} at ${formatTimestamp(diagnosis.at)}.${liveChildrenTail(diagnosis)}`;
+            return `${logSymbols.success} ${styleText('green', 'completed')} at ${formatDateTime(diagnosis.at)}.${liveChildrenTail(diagnosis)}`;
         case 'aborted': {
             const tail = diagnosis.reason !== undefined ? ` — ${diagnosis.reason}` : '';
-            return `${logSymbols.info} ${styleText('dim', 'aborted')} at ${formatTimestamp(diagnosis.at)}${tail}.${liveChildrenTail(diagnosis)}`;
+            return `${logSymbols.info} ${styleText('dim', 'aborted')} at ${formatDateTime(diagnosis.at)}${tail}.${liveChildrenTail(diagnosis)}`;
         }
         case 'stuck':
-            return `${logSymbols.warning} ${styleText('yellow', 'STUCK')} — ${causeDetail(diagnosis.cause).headline}`;
+            return stuckHeadline(diagnosis.cause);
     }
 }
 export function rawTransitionProjection(evaluation) {
@@ -186,7 +125,7 @@ export function rawTransitionProjection(evaluation) {
         })),
     }));
 }
-export function renderDiagnosis({ diagnosis, input, remediations, explanations, }) {
+export function renderDiagnosis({ diagnosis, input, remediations, explanations, allMissingDocuments, }) {
     const lines = [statusLine(diagnosis)];
     const inFlight = diagnosis.state === 'progressing' ||
         diagnosis.state === 'waiting' ||
@@ -201,14 +140,7 @@ export function renderDiagnosis({ diagnosis, input, remediations, explanations,
     if (diagnosis.state === 'blocked') {
         lines.push('', ...blockedLines(diagnosis));
     }
-    if (diagnosis.state === 'stuck') {
-        const detail = causeDetail(diagnosis.cause);
-        const runnable = remediations.filter((r) => r.available);
-        lines.push('', sectionHeader("Why it's stuck"), ...detail.why);
-        if (runnable.length > 0) {
-            lines.push('', sectionHeader('Suggested fix'), ...remediationLines(runnable));
-        }
-    }
+    lines.push(...stuckDiagnosisLines({ diagnosis, allMissingDocuments, remediations }));
     return lines;
 }
 export default class Diagnose extends WorkflowCommand {
@@ -249,7 +181,13 @@ export default class Diagnose extends WorkflowCommand {
         this.log(instanceHeader(evaluation.instance));
         this.log('');
         const explanations = new Map(unsatisfiedTransitionSummaries(evaluation).map((entry) => [entry.transition, entry.summary]));
-        for (const line of renderDiagnosis({ diagnosis, input, remediations, explanations })) {
+        for (const line of renderDiagnosis({
+            diagnosis,
+            input,
+            remediations,
+            explanations,
+            allMissingDocuments: evaluation.missingDocuments,
+        })) {
             this.log(line);
         }
     }

package/dist/commands/workflows/list.d.ts

@@ -1,4 +1,4 @@
-import { type GdrUri, type TerminalState } from '@sanity/workflow-engine';
+import { type AssignmentIdentity, type AssignmentStateCounts, type GdrUri, type StageEntry, type TerminalState } from '@sanity/workflow-engine';
 import { WorkflowCommand } from '../../lib/base-command.ts';
 interface InstanceRow {
     _id: string;
@@ -10,12 +10,16 @@ interface InstanceRow {
     lastChangedAt: string;
     modelVersion?: number | null;
     minReaderModel?: number | null;
+    stages?: StageEntry[];
 }
 interface ListFlags {
     'include-completed': boolean;
     failed: boolean;
     definition?: string | undefined;
     document?: string | undefined;
+    'assignment-user'?: string | undefined;
+    'assignment-role'?: string[] | undefined;
+    'assignment-state'?: string[] | undefined;
     tag?: string | undefined;
     limit: number;
 }
@@ -38,13 +42,14 @@ export declare function buildListQuery(flags: ListFlags): {
     params: Record<string, unknown>;
 };
 /** Map a queried instance to its display row (derives the status column). */
-export declare function instanceRow(r: InstanceRow): {
+export declare function instanceRow(r: InstanceRow, identity?: AssignmentIdentity): {
     _id: string;
     definition: string;
     tag: string;
     currentStage: string;
     status: TerminalState;
     lastChangedAt: string;
+    assignment?: AssignmentStateCounts;
 };
 export default class List extends WorkflowCommand {
     static description: string;
@@ -55,6 +60,9 @@ export default class List extends WorkflowCommand {
         failed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         definition: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         document: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'assignment-user': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'assignment-role': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'assignment-state': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };

package/dist/commands/workflows/list.js

@@ -1,12 +1,13 @@
 import { Flags } from '@oclif/core';
-import { WORKFLOW_INSTANCE_TYPE, assertReadableModel, documentPrefilter, inFlightFilter, instanceWatchesDocument, tagScopeFilter, terminalState, } from '@sanity/workflow-engine';
+import { formatTimeAgo } from '@sanity/cli-core/dates';
+import { WORKFLOW_INSTANCE_TYPE, assignmentPrefilter, assertReadableModel, documentPrefilter, inFlightFilter, instanceWatchesDocument, instanceAssignmentStateCounts, tagScopeFilter, terminalState, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
 import { WorkflowCommand } from "../../lib/base-command.js";
 import { resolveReadTargets } from "../../lib/context.js";
 import { failOnThrow } from "../../lib/fail.js";
 import { jsonFlags, tagFlags } from "../../lib/flags.js";
 import { logJsonListing, runReadAcrossTargets } from "../../lib/read-fanout.js";
-import { formatAge, logClippedTable } from "../../lib/ui.js";
+import { logClippedTable } from "../../lib/ui.js";
 const DOCUMENT_LIST_PROJECTION = `{
   _type,
   _id,
@@ -39,6 +40,12 @@ export function buildListQuery(flags) {
         filters.push(tagScopeFilter());
         params['tag'] = flags.tag;
     }
+    const assignment = assignmentFilter(flags);
+    if (assignment !== undefined) {
+        const armParams = {};
+        filters.push(assignmentPrefilter(assignment, armParams));
+        Object.assign(params, armParams);
+    }
     if (flags.document) {
         const armParams = {};
         filters.push(`(${documentPrefilter([flags.document], armParams)})`);
@@ -60,10 +67,28 @@ export function buildListQuery(flags) {
       lastChangedAt,
       modelVersion,
       minReaderModel
+      ${assignment === undefined ? '' : ', stages'}
     }`;
     return { groq, params };
 }
-export function instanceRow(r) {
+function assignmentFilter(flags) {
+    const userId = flags['assignment-user'];
+    const roles = flags['assignment-role'];
+    const rawStates = flags['assignment-state'];
+    if (userId === undefined) {
+        if (roles !== undefined || rawStates !== undefined) {
+            throw new Error('--assignment-role and --assignment-state require --assignment-user');
+        }
+        return undefined;
+    }
+    const states = rawStates;
+    return {
+        userId,
+        ...(roles === undefined ? {} : { roles }),
+        ...(states === undefined ? {} : { states }),
+    };
+}
+export function instanceRow(r, identity) {
     return {
         _id: r._id,
         definition: r.definition,
@@ -74,8 +99,57 @@ export function instanceRow(r) {
             ...(r.abortedAt != null ? { abortedAt: r.abortedAt } : {}),
         }),
         lastChangedAt: r.lastChangedAt,
+        ...(identity === undefined ? {} : { assignment: assignmentCounts(r, identity) }),
     };
 }
+function assignmentCounts(row, identity) {
+    return instanceAssignmentStateCounts({ currentStage: row.currentStage, stages: row.stages ?? [] }, identity);
+}
+function assignmentIdentityFor(flags) {
+    const assignment = assignmentFilter(flags);
+    return assignment === undefined
+        ? undefined
+        : { userId: assignment.userId, roles: assignment.roles ?? [] };
+}
+async function logTargetInstances(args) {
+    const fetched = await fetchRows(args);
+    if (fetched.rows.length === 0) {
+        const message = fetched.hasMore
+            ? `no matches in the first ${args.limit} candidates — raise --limit to search further`
+            : 'no instances match';
+        args.log(`${logSymbols.info} ${message}`);
+        return;
+    }
+    logClippedTable({
+        rows: fetched.rows,
+        limit: args.limit,
+        moreAvailable: fetched.hasMore,
+        headers: [
+            'instance',
+            'workflow',
+            'tag',
+            'stage',
+            'status',
+            'updated',
+            ...(args.identity === undefined ? [] : ['assignment u/r/h']),
+        ],
+        toCells: (candidate) => {
+            const row = instanceRow(candidate, args.identity);
+            return [
+                row._id,
+                row.definition,
+                row.tag,
+                row.currentStage,
+                row.status,
+                formatTimeAgo(new Date(row.lastChangedAt)),
+                ...(row.assignment === undefined
+                    ? []
+                    : [`${row.assignment.unrouted}/${row.assignment.routed}/${row.assignment.held}`]),
+            ];
+        },
+        log: args.log,
+    });
+}
 export default class List extends WorkflowCommand {
     static description = 'List workflow instances in the configured dataset (in-flight by default).';
     static examples = [
@@ -83,6 +157,7 @@ export default class List extends WorkflowCommand {
         '<%= config.bin %> workflows list --include-completed',
         '<%= config.bin %> workflows list --definition productLaunch',
         '<%= config.bin %> workflows list --document dataset:proj:ds:article-1',
+        '<%= config.bin %> workflows list --assignment-user gAda --assignment-role legal --assignment-state routed',
         '<%= config.bin %> workflows list --tag prod',
         '<%= config.bin %> workflows list --json',
     ];
@@ -103,6 +178,18 @@ export default class List extends WorkflowCommand {
             description: 'Only instances that reference this document (resource-qualified GDR URI, ' +
                 'e.g. "dataset:proj:ds:article-1").',
         }),
+        'assignment-user': Flags.string({
+            description: 'Account-global user id used for viewer-scoped assignment filtering and counts.',
+        }),
+        'assignment-role': Flags.string({
+            description: 'A literal project role held by --assignment-user. Repeat for multiple roles.',
+            multiple: true,
+        }),
+        'assignment-state': Flags.string({
+            description: 'Assignment state to include: unrouted, routed (offered through a supplied role), or held. Repeat for multiple states.',
+            multiple: true,
+            options: ['unrouted', 'routed', 'held'],
+        }),
         limit: Flags.integer({
             description: 'Maximum rows to return.',
             default: 50,
@@ -112,8 +199,9 @@ export default class List extends WorkflowCommand {
     async run() {
         const { flags } = await this.parse(List);
         const targets = await resolveReadTargets(flags);
-        const { groq, params } = failOnThrow('Invalid --document:', () => buildListQuery(flags));
+        const { groq, params } = failOnThrow('Invalid list filter:', () => buildListQuery(flags));
         const document = flags.document;
+        const identity = assignmentIdentityFor(flags);
         if (flags.json) {
             await logJsonListing({
                 targets,
@@ -121,43 +209,22 @@ export default class List extends WorkflowCommand {
                 limit: flags.limit,
                 log: (line) => this.log(line),
                 fetch: ({ client }) => fetchRows({ client, groq, params, document, limit: flags.limit }),
-                toRow: instanceRow,
+                toRow: (row) => instanceRow(row, identity),
             });
             return;
         }
         const failures = await runReadAcrossTargets({
             targets,
             log: (line) => this.log(line),
-            run: async ({ client }) => {
-                const fetched = await fetchRows({ client, groq, params, document, limit: flags.limit });
-                if (fetched.rows.length === 0) {
-                    if (fetched.hasMore) {
-                        this.log(`${logSymbols.info} no matches in the first ${flags.limit} candidates — raise --limit to search further`);
-                    }
-                    else {
-                        this.log(`${logSymbols.info} no instances match`);
-                    }
-                    return;
-                }
-                logClippedTable({
-                    rows: fetched.rows,
-                    limit: flags.limit,
-                    moreAvailable: fetched.hasMore,
-                    headers: ['instance', 'workflow', 'tag', 'stage', 'status', 'updated'],
-                    toCells: (r) => {
-                        const row = instanceRow(r);
-                        return [
-                            row._id,
-                            row.definition,
-                            row.tag,
-                            row.currentStage,
-                            row.status,
-                            formatAge(row.lastChangedAt),
-                        ];
-                    },
-                    log: (line) => this.log(line),
-                });
-            },
+            run: ({ client }) => logTargetInstances({
+                client,
+                groq,
+                params,
+                document,
+                limit: flags.limit,
+                identity,
+                log: (line) => this.log(line),
+            }),
         });
         if (failures.length > 0) {
             this.exit(1);

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

@@ -1,5 +1,6 @@
 import { type WorkflowInstance } from '@sanity/workflow-engine';
 import { WorkflowCommand } from '../../lib/base-command.ts';
+import { type InstanceDiagnostic } from '../../lib/cause-detail.ts';
 export default class Show extends WorkflowCommand {
     static description: string;
     static examples: string[];
@@ -12,15 +13,12 @@ export default class Show extends WorkflowCommand {
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private diagnostic;
 }
 /** The summary block at the top of `show` (and reused by `diagnose` /
  *  `fire-action`): a bold workflow + id title, then aligned detail rows. */
 export declare function instanceHeader(instance: WorkflowInstance): string;
-/**
- * The per-instance body lines: every stage with its activities, any pending
- * effects, and (optionally) the history log. Pure so it can be asserted
- * without driving the oclif command.
- */
 export declare function describeInstance(instance: WorkflowInstance, options: {
     includeHistory: boolean;
+    diagnostic?: InstanceDiagnostic | undefined;
 }): string[];

package/dist/commands/workflows/show.js

@@ -1,11 +1,14 @@
 import { styleText } from 'node:util';
 import { Args, Flags } from '@oclif/core';
-import { abortReason, displayTitle, terminalState, } from '@sanity/workflow-engine';
+import { formatDateTime } from '@sanity/cli-core/dates';
+import { abortReason, workflow, errorMessage, displayTitle, terminalState, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
 import { WorkflowCommand } from "../../lib/base-command.js";
+import { stuckDiagnosisLines, stuckHeadline, } from "../../lib/cause-detail.js";
 import { findInstance, resolveReadTargets } from "../../lib/context.js";
 import { jsonFlags, tagFlags } from "../../lib/flags.js";
-import { formatKeyValue, formatTimestamp, sectionHeader, activityIcon } from "../../lib/ui.js";
+import { baseEngineArgs } from "../../lib/operation-args.js";
+import { formatKeyValue, sectionHeader, activityIcon } from "../../lib/ui.js";
 export default class Show extends WorkflowCommand {
     static description = 'Show the state, activities, and effects of a workflow instance.';
     static examples = [
@@ -41,30 +44,49 @@ export default class Show extends WorkflowCommand {
             this.log(JSON.stringify(instance, null, 2));
             return;
         }
+        const diagnostic = await this.diagnostic(hit);
         this.log(instanceHeader(instance));
         this.log('');
         for (const line of describeInstance(instance, {
             includeHistory: flags.include.includes('history'),
+            diagnostic,
         })) {
             this.log(line);
         }
     }
+    async diagnostic(hit) {
+        const { instance } = hit;
+        if (terminalState(instance) !== 'in-flight')
+            return undefined;
+        try {
+            const { diagnosis, evaluation, remediations } = await workflow.diagnose({
+                client: hit.client,
+                ...baseEngineArgs({ tag: instance.tag, workflowResource: instance.workflowResource }),
+                instanceId: instance._id,
+            });
+            return { diagnosis, remediations, allMissingDocuments: evaluation.missingDocuments };
+        }
+        catch (error) {
+            this.warn(`Could not evaluate the instance: ${errorMessage(error)}. Showing stored state; reference availability is unknown.`);
+            return undefined;
+        }
+    }
 }
 const HEADER_PAD = 9;
 export function instanceHeader(instance) {
     const title = `${styleText('bold', `${instance.definition} v${instance.pinnedVersion}`)}  ${styleText('cyan', instance._id)}`;
     const rows = [
         formatKeyValue({ key: 'Stage', value: instance.currentStage, padTo: HEADER_PAD }),
-        formatKeyValue({ key: 'Started', value: formatTimestamp(instance.startedAt), padTo: HEADER_PAD }),
+        formatKeyValue({ key: 'Started', value: formatDateTime(instance.startedAt), padTo: HEADER_PAD }),
     ];
     if (terminalState(instance) === 'aborted' && instance.abortedAt !== undefined) {
         const reason = abortReason(instance);
         const tail = reason ? ` — ${reason}` : '';
-        const value = `${formatTimestamp(instance.abortedAt)}${tail}`;
+        const value = `${formatDateTime(instance.abortedAt)}${tail}`;
         rows.push(formatKeyValue({ key: 'Aborted', value, padTo: HEADER_PAD, emphasis: 'yellow' }));
     }
     else if (instance.completedAt) {
-        const value = formatTimestamp(instance.completedAt);
+        const value = formatDateTime(instance.completedAt);
         rows.push(formatKeyValue({ key: 'Completed', value, padTo: HEADER_PAD, emphasis: 'green' }));
     }
     else {
@@ -76,11 +98,17 @@ export function instanceHeader(instance) {
 }
 export function describeInstance(instance, options) {
     return [
+        ...diagnosticLines(options.diagnostic),
         ...stageLines(instance),
         ...pendingEffectLines(instance),
         ...(options.includeHistory ? historyLines(instance) : []),
     ];
 }
+function diagnosticLines(diagnostic) {
+    if (diagnostic?.diagnosis.state !== 'stuck')
+        return [];
+    return [stuckHeadline(diagnostic.diagnosis.cause), ...stuckDiagnosisLines(diagnostic), ''];
+}
 function stageLines(instance) {
     return [
         sectionHeader('Stages'),
@@ -92,7 +120,7 @@ function stageLines(instance) {
 }
 function stageMarker(stage) {
     return stage.exitedAt
-        ? styleText('dim', ` (exited ${formatTimestamp(stage.exitedAt)})`)
+        ? styleText('dim', ` (exited ${formatDateTime(stage.exitedAt)})`)
         : styleText('cyan', ' (current)');
 }
 function pendingEffectLines(instance) {
@@ -109,6 +137,6 @@ function historyLines(instance) {
     return [
         '',
         sectionHeader('History'),
-        ...instance.history.map((entry) => `  ${styleText('dim', `[${formatTimestamp(entry.at)}]`)} ${displayTitle(entry._type)}`),
+        ...instance.history.map((entry) => `  ${styleText('dim', `[${formatDateTime(entry.at)}]`)} ${displayTitle(entry._type)}`),
     ];
 }

package/dist/commands/workflows/tail.js

@@ -1,12 +1,12 @@
 import { styleText } from 'node:util';
 import { Args } from '@oclif/core';
+import { formatDateTime } from '@sanity/cli-core/dates';
 import { assertReadableModel, displayTitle, errorMessage, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
 import { WorkflowCommand } from "../../lib/base-command.js";
 import { findInstance, resolveReadTargets } from "../../lib/context.js";
 import { fail, failureDetail } from "../../lib/fail.js";
 import { tagFlags } from "../../lib/flags.js";
-import { formatTimestamp } from "../../lib/ui.js";
 const TAIL_TAG = 'tail';
 export default class Tail extends WorkflowCommand {
     static description = 'Stream new history entries on a workflow instance as they land in the dataset.';
@@ -70,7 +70,7 @@ export default class Tail extends WorkflowCommand {
         const next = assertReadableModel(raw);
         const newEntries = next.history.slice(seen);
         for (const entry of newEntries) {
-            this.log(`${styleText('dim', `[${formatTimestamp(entry.at)}]`)} ${styleText('cyan', displayTitle(entry._type))}`);
+            this.log(`${styleText('dim', `[${formatDateTime(entry.at)}]`)} ${styleText('cyan', displayTitle(entry._type))}`);
         }
         return Math.max(seen, next.history.length);
     }

package/dist/hooks/prerun/telemetry.d.ts

@@ -6,5 +6,11 @@ import type { Hook } from '@oclif/core';
  *  resolved from raw argv because the store is built before oclif parses
  *  flags. Skips non-workflows commands when this package is mounted as a
  *  host plugin so `sanity dataset list` does not inherit the shell. */
+export declare function installPrerunTelemetry(args: {
+    bin: string;
+    version: string;
+    commandId: string | undefined;
+    argv: string[];
+}): Promise<void>;
 declare const hook: Hook<'prerun'>;
 export default hook;

package/dist/hooks/prerun/telemetry.js

@@ -1,16 +1,23 @@
 import { shouldRunWorkflowCliTelemetry } from "../../command-ids.js";
 import { shouldForceShareTelemetry } from "../../lib/share-definitions.js";
 import { setupCliTelemetry } from "../../lib/telemetry-setup.js";
-const hook = async function ({ config, Command, argv }) {
-    if (!shouldRunWorkflowCliTelemetry({
-        bin: config.bin,
-        commandId: Command?.id,
-    })) {
+export async function installPrerunTelemetry(args) {
+    const { bin, version, commandId, argv } = args;
+    if (!shouldRunWorkflowCliTelemetry({ bin, commandId })) {
         return;
     }
     await setupCliTelemetry({
-        cliVersion: config.version,
-        forceSend: shouldForceShareTelemetry({ commandId: Command?.id, argv }),
+        cliVersion: version,
+        forceSend: shouldForceShareTelemetry({ commandId, argv }),
+        ...(commandId !== undefined ? { commandId } : {}),
+    });
+}
+const hook = async function ({ config, Command, argv }) {
+    await installPrerunTelemetry({
+        bin: config.bin,
+        version: config.version,
+        commandId: Command?.id,
+        argv,
     });
 };
 export default hook;