@sanity/workflow-cli 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @sanity/workflow-cli
 
+## 0.22.0
+
+### Minor Changes
+
+- 1c6d4c0: Name the target deployment and resource on `deploy` progress and result lines. The spinner and completion line now read `Deploying N definition(s) to <name> (<tag>) → <resource>…` / `Processed N definition(s) · <name> (<tag>) → <resource>` (and the dry-run equivalents), so a single-deployment run — the common case, which prints no per-batch banner — always shows where the deploy landed.
+- fb42001: The instance-keyed commands — `diagnose`, `fire-action`, `set-stage`, `abort`, `reset-activity` — now locate an instance by fanning out across every configured resource, the same way `show` and the other read commands already do. Passing an instance id is enough: on a config that spans several resources they no longer prompt for (or require) a `--deployment` / `--tag` selector — those stay as optional narrowers. As an optimization, an id carrying the engine's default `<tag>.` mint prefix probes that tag's resource first and skips the fan-out on a hit. `reset-activity` also gains the `--deployment` narrower its siblings already had.
+- 84ff807: The read commands — `list`, `show`, `definition list`, `definition show` — now take `--json`, emitting structured output on stdout for parity with the verb commands. `show` and `definition show` print the fetched document as stored; `list` and `definition list` print their table's row view (each row annotated with the `resource` it came from) under a `truncated` flag. A JSON read spanning several resources is all-or-nothing: an unreadable resource fails the whole command rather than emitting a partial listing a script would mistake for the complete result.
+
+### Patch Changes
+
+- a8c460c: Colour the whole terminal-status row in the instance header — aborted rows render bold yellow, completed rows bold green — so a finished instance stands out from the neutral detail rows instead of only its timestamp carrying colour.
+- Updated dependencies [88ba4ba]
+  - @sanity/workflow-engine@0.22.0
+
 ## 0.21.0
 
 ### Minor Changes

package/dist/commands/editorial-workflows/definition/list.d.ts

@@ -26,10 +26,26 @@ export default class DefinitionList extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }
+/** Map a queried definition to its display row. Drops the stamp pair (gate
+ *  plumbing, not view data) and `_id` — `tag.name.vN`, which just repeats
+ *  name + tag + version, and no command takes an `_id` anyway (they take
+ *  name + --tag/--version); `name vN` is this CLI's identifier format (the
+ *  `definition show` title). */
+export declare function definitionRow(r: DefinitionListRow): {
+    name: string;
+    version: number;
+    title: string;
+    tag: string;
+    stageCount: number;
+    inFlightCount: number;
+    totalInstances: number;
+    _createdAt: string;
+};
 export {};

package/dist/commands/editorial-workflows/definition/list.js

@@ -3,8 +3,8 @@ import { WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, assertReadableModel,
 import logSymbols from 'log-symbols';
 import { WorkflowCommand } from "../../../lib/base-command.js";
 import { resolveReadTargets } from "../../../lib/context.js";
-import { tagFlags } from "../../../lib/flags.js";
-import { runReadAcrossTargets } from "../../../lib/read-fanout.js";
+import { jsonFlags, tagFlags } from "../../../lib/flags.js";
+import { logJsonListing, runReadAcrossTargets } from "../../../lib/read-fanout.js";
 import { logClippedTable } from "../../../lib/ui.js";
 export function buildDefinitionListQuery(flags) {
     const params = { limit: flags.limit + 1 };
@@ -45,6 +45,7 @@ export default class DefinitionList extends WorkflowCommand {
     static examples = [
         '<%= config.bin %> definition list',
         '<%= config.bin %> definition list --tag prod',
+        '<%= config.bin %> definition list --json',
     ];
     static flags = {
         ...tagFlags,
@@ -55,35 +56,48 @@ export default class DefinitionList extends WorkflowCommand {
         name: Flags.string({
             description: 'Filter to a single workflow definition name (e.g. product-launch).',
         }),
+        ...jsonFlags,
     };
     async run() {
         const { flags } = await this.parse(DefinitionList);
         const targets = await resolveReadTargets(flags);
         const { groq, params } = buildDefinitionListQuery(flags);
+        if (flags.json) {
+            await logJsonListing({
+                targets,
+                key: 'definitions',
+                limit: flags.limit,
+                log: (line) => this.log(line),
+                fetch: ({ client }) => fetchDefinitionRows({ client, groq, params, limit: flags.limit }),
+                toRow: definitionRow,
+            });
+            return;
+        }
         const failures = await runReadAcrossTargets({
             targets,
             log: (line) => this.log(line),
             run: async ({ client }) => {
-                const fetched = (await client.fetch(groq, params, {
-                    tag: 'definition.list',
-                })).map(assertReadableModel);
-                if (!fetched.length) {
+                const fetched = await fetchDefinitionRows({ client, groq, params, limit: flags.limit });
+                if (!fetched.rows.length) {
                     this.log(`${logSymbols.info} no definitions found`);
                     return;
                 }
                 logClippedTable({
-                    rows: fetched,
+                    rows: fetched.rows,
                     limit: flags.limit,
                     headers: ['workflow', 'title', 'tag', 'stages', 'in flight', 'instances', 'created'],
-                    toCells: (r) => [
-                        `${r.name} v${r.version}`,
-                        r.title,
-                        r.tag,
-                        String(r.stageCount),
-                        String(r.inFlightCount),
-                        String(r.totalInstances),
-                        r._createdAt,
-                    ],
+                    toCells: (r) => {
+                        const row = definitionRow(r);
+                        return [
+                            `${row.name} v${row.version}`,
+                            row.title,
+                            row.tag,
+                            String(row.stageCount),
+                            String(row.inFlightCount),
+                            String(row.totalInstances),
+                            row._createdAt,
+                        ];
+                    },
                     log: (line) => this.log(line),
                 });
             },
@@ -93,3 +107,19 @@ export default class DefinitionList extends WorkflowCommand {
         }
     }
 }
+export function definitionRow(r) {
+    return {
+        name: r.name,
+        version: r.version,
+        title: r.title,
+        tag: r.tag,
+        stageCount: r.stageCount,
+        inFlightCount: r.inFlightCount,
+        totalInstances: r.totalInstances,
+        _createdAt: r._createdAt,
+    };
+}
+async function fetchDefinitionRows({ client, groq, params, limit, }) {
+    const rows = await client.fetch(groq, params, { tag: 'definition.list' });
+    return { rows: rows.map(assertReadableModel), hasMore: rows.length > limit };
+}

package/dist/commands/editorial-workflows/definition/show.d.ts

@@ -8,6 +8,7 @@ export default class DefinitionShow extends WorkflowCommand {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         version: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };

package/dist/commands/editorial-workflows/definition/show.js

@@ -6,7 +6,7 @@ import { WorkflowCommand } from "../../../lib/base-command.js";
 import { resolveReadTargets, soleHitOrFail } from "../../../lib/context.js";
 import { buildDefinitionShowQuery, buildDefinitionTagsQuery } from "../../../lib/definitions.js";
 import { fail } from "../../../lib/fail.js";
-import { tagFlags } from "../../../lib/flags.js";
+import { jsonFlags, tagFlags } from "../../../lib/flags.js";
 import { formatKeyValue, resourceLabel, sectionHeader } from "../../../lib/ui.js";
 export default class DefinitionShow extends WorkflowCommand {
     static aliases = ['definition:show'];
@@ -17,6 +17,7 @@ export default class DefinitionShow extends WorkflowCommand {
     static flags = {
         ...tagFlags,
         version: Flags.integer({ description: 'Specific version (default: latest).' }),
+        ...jsonFlags,
     };
     async run() {
         const { args, flags } = await this.parse(DefinitionShow);
@@ -32,6 +33,10 @@ export default class DefinitionShow extends WorkflowCommand {
                 exit: 1,
             });
         }
+        if (flags.json) {
+            this.log(JSON.stringify(def, null, 2));
+            return;
+        }
         this.log(definitionHeader(def, def.tag));
         this.log('');
         for (const line of describeDefinition(def)) {

package/dist/commands/editorial-workflows/deploy.d.ts

@@ -77,6 +77,24 @@ export declare function deploymentBanner({ deployment, index, total, }: {
     index: number;
     total: number;
 }): string | undefined;
+/** The deploy target as one label — the deployment's friendly name/tag
+ *  ({@link deploymentLabel}) and the resource it writes to
+ *  ({@link resourceLabel}) — so every progress and result line names where a
+ *  deploy landed, including the common single-deployment run that prints no
+ *  banner. */
+export declare function targetLabel(deployment: WorkflowDeployment): string;
+/** The deploy spinner's progress line — names the full target it writes to. */
+export declare function deployStartLine(count: number, where: string): string;
+/** The dry-run spinner's progress line — a diff reads the resource's deployed
+ *  state, so it names the resource it compares against, not the deployment. */
+export declare function dryRunStartLine(count: number, resource: string): string;
+/** A completed deploy/dry-run result line: the past-tense verb, the count, and
+ *  the full target, so a finished run always shows where it landed. */
+export declare function resultLine({ verb, count, where, }: {
+    verb: 'Processed' | 'Diffed';
+    count: number;
+    where: string;
+}): string;
 /** One line per deployed definition, symbol-tagged by its result status,
  *  followed by any advisory effect-output lint warnings indented beneath it. */
 export declare function deployResultLines(results: DeployDefinitionResult[]): string[];

package/dist/commands/editorial-workflows/deploy.js

@@ -13,7 +13,7 @@ import { loadWorkflowConfig } from "../../lib/load-config.js";
 import { deploymentLabel, deploymentToTarget, selectDeployments, } from "../../lib/select-deployment.js";
 import { shareDefinitionsAfterDeploy } from "../../lib/share-definitions.js";
 import { cliTelemetry } from "../../lib/telemetry.js";
-import { groupBanner } from "../../lib/ui.js";
+import { groupBanner, resourceLabel } from "../../lib/ui.js";
 export default class Deploy extends WorkflowCommand {
     static aliases = ['deploy'];
     static description = 'Validate, diff, and deploy workflow definitions to the resource bound by the selected deployment.';
@@ -110,14 +110,16 @@ export default class Deploy extends WorkflowCommand {
     }
     async processDeployment({ deployment, defs, dryRun, client, }) {
         const target = deploymentToTarget(deployment);
+        const where = targetLabel(deployment);
+        const resource = resourceLabel(deployment.workflowResource);
         if (dryRun) {
-            await this.runDryRun({ client, defs, target });
+            await this.runDryRun({ client, defs, target, where, resource });
             return undefined;
         }
-        return this.executeDeploy({ client, defs, target });
+        return this.executeDeploy({ client, defs, target, where });
     }
-    async executeDeploy({ client, defs, target, }) {
-        const spinner = ora(`Deploying ${defs.length} definition(s)…`).start();
+    async executeDeploy({ client, defs, target, where, }) {
+        const spinner = ora(deployStartLine(defs.length, where)).start();
         try {
             const deployed = await workflow.deployDefinitions({
                 ...target,
@@ -125,7 +127,7 @@ export default class Deploy extends WorkflowCommand {
                 definitions: defs,
                 telemetry: cliTelemetry().logger,
             });
-            spinner.succeed(`Processed ${deployed.results.length} definition(s)`);
+            spinner.succeed(resultLine({ verb: 'Processed', count: deployed.results.length, where }));
             for (const line of deployResultLines(deployed.results))
                 this.log(line);
             return deployed;
@@ -135,11 +137,11 @@ export default class Deploy extends WorkflowCommand {
             throw error;
         }
     }
-    async runDryRun({ client, defs, target, }) {
-        const spinner = ora(`Diffing ${defs.length} definition(s) against dataset…`).start();
+    async runDryRun({ client, defs, target, where, resource, }) {
+        const spinner = ora(dryRunStartLine(defs.length, resource)).start();
         try {
             const entries = await computeDiffEntries({ client, defs, target });
-            spinner.succeed(`Diffed ${defs.length} definition(s)`);
+            spinner.succeed(resultLine({ verb: 'Diffed', count: defs.length, where }));
             for (const line of diffReport(entries))
                 this.log(line);
         }
@@ -194,6 +196,18 @@ export function deploySummary({ total, failures, }) {
 export function deploymentBanner({ deployment, index, total, }) {
     return groupBanner({ label: deploymentLabel(deployment), index, total });
 }
+export function targetLabel(deployment) {
+    return `${deploymentLabel(deployment)} → ${resourceLabel(deployment.workflowResource)}`;
+}
+export function deployStartLine(count, where) {
+    return `Deploying ${count} definition(s) to ${where}…`;
+}
+export function dryRunStartLine(count, resource) {
+    return `Diffing ${count} definition(s) against ${resource}…`;
+}
+export function resultLine({ verb, count, where, }) {
+    return `${verb} ${count} definition(s) · ${where}`;
+}
 export function deployResultLines(results) {
     const symbols = {
         created: logSymbols.success,

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

@@ -51,6 +51,7 @@ export default class List extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'include-completed': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         failed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         definition: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/editorial-workflows/list.js

@@ -4,8 +4,8 @@ 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 { tagFlags } from "../../lib/flags.js";
-import { runReadAcrossTargets } from "../../lib/read-fanout.js";
+import { jsonFlags, tagFlags } from "../../lib/flags.js";
+import { logJsonListing, runReadAcrossTargets } from "../../lib/read-fanout.js";
 import { formatAge, logClippedTable } from "../../lib/ui.js";
 const DOCUMENT_LIST_PROJECTION = `{
   _type,
@@ -85,6 +85,7 @@ export default class List extends WorkflowCommand {
         '<%= config.bin %> list --definition productLaunch',
         '<%= config.bin %> list --document dataset:proj:ds:article-1',
         '<%= config.bin %> list --tag prod',
+        '<%= config.bin %> list --json',
     ];
     static flags = {
         ...tagFlags,
@@ -107,12 +108,24 @@ export default class List extends WorkflowCommand {
             description: 'Maximum rows to return.',
             default: 50,
         }),
+        ...jsonFlags,
     };
     async run() {
         const { flags } = await this.parse(List);
         const targets = await resolveReadTargets(flags);
         const { groq, params } = failOnThrow('Invalid --document:', () => buildListQuery(flags));
         const document = flags.document;
+        if (flags.json) {
+            await logJsonListing({
+                targets,
+                key: 'instances',
+                limit: flags.limit,
+                log: (line) => this.log(line),
+                fetch: ({ client }) => fetchRows({ client, groq, params, document, limit: flags.limit }),
+                toRow: instanceRow,
+            });
+            return;
+        }
         const failures = await runReadAcrossTargets({
             targets,
             log: (line) => this.log(line),

package/dist/commands/editorial-workflows/reset-activity.d.ts

@@ -11,6 +11,7 @@ export default class ResetActivity extends WorkflowCommand {
     };
     static flags: {
         skip: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        deployment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/editorial-workflows/reset-activity.js

@@ -3,7 +3,7 @@ import { Args, Flags } from '@oclif/core';
 import { workflow } from '@sanity/workflow-engine';
 import { WorkflowCommand } from "../../lib/base-command.js";
 import { resolveInstanceContext } from "../../lib/context.js";
-import { tagFlags } from "../../lib/flags.js";
+import { instanceFlags } from "../../lib/flags.js";
 import { buildOperationArgs } from "../../lib/operation-args.js";
 import { cascadeTail, runWriteVerb, } from "../../lib/ops-report.js";
 export default class ResetActivity extends WorkflowCommand {
@@ -18,7 +18,7 @@ export default class ResetActivity extends WorkflowCommand {
         activity: Args.string({ required: true, description: 'Activity name within the current stage.' }),
     };
     static flags = {
-        ...tagFlags,
+        ...instanceFlags,
         skip: Flags.boolean({
             default: false,
             description: 'Bypass the activity (mark it skipped) instead of re-running it (back to active).',

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

@@ -8,6 +8,7 @@ export default class Show extends WorkflowCommand {
         instanceId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         include: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };

package/dist/commands/editorial-workflows/show.js

@@ -4,7 +4,7 @@ import { abortReason, displayTitle, terminalState, } from '@sanity/workflow-engi
 import logSymbols from 'log-symbols';
 import { WorkflowCommand } from "../../lib/base-command.js";
 import { findInstance, resolveReadTargets } from "../../lib/context.js";
-import { tagFlags } from "../../lib/flags.js";
+import { jsonFlags, tagFlags } from "../../lib/flags.js";
 import { formatKeyValue, formatTimestamp, sectionHeader, activityIcon } from "../../lib/ui.js";
 export default class Show extends WorkflowCommand {
     static aliases = ['show'];
@@ -12,6 +12,7 @@ export default class Show extends WorkflowCommand {
     static examples = [
         '<%= config.bin %> show wf-instance.abc123',
         '<%= config.bin %> show wf-instance.abc123 --include history',
+        '<%= config.bin %> show wf-instance.abc123 --json',
     ];
     static args = {
         instanceId: Args.string({
@@ -22,11 +23,12 @@ export default class Show extends WorkflowCommand {
     static flags = {
         ...tagFlags,
         include: Flags.string({
-            description: 'Optional sections to include in output.',
+            description: 'Optional sections to include in rendered output (--json always carries the full document).',
             options: ['history'],
             multiple: true,
             default: [],
         }),
+        ...jsonFlags,
     };
     async run() {
         const { args, flags } = await this.parse(Show);
@@ -36,6 +38,10 @@ export default class Show extends WorkflowCommand {
             this.error(`${logSymbols.error} no instance with id "${args.instanceId}"`, { exit: 1 });
         }
         const { instance } = hit;
+        if (flags.json) {
+            this.log(JSON.stringify(instance, null, 2));
+            return;
+        }
         this.log(instanceHeader(instance));
         this.log('');
         for (const line of describeInstance(instance, {
@@ -55,14 +61,16 @@ export function instanceHeader(instance) {
     if (terminalState(instance) === 'aborted' && instance.abortedAt !== undefined) {
         const reason = abortReason(instance);
         const tail = reason ? ` — ${reason}` : '';
-        const value = styleText('yellow', `${formatTimestamp(instance.abortedAt)}${tail}`);
-        rows.push(formatKeyValue({ key: 'Aborted', value, padTo: HEADER_PAD }));
+        const value = `${formatTimestamp(instance.abortedAt)}${tail}`;
+        rows.push(formatKeyValue({ key: 'Aborted', value, padTo: HEADER_PAD, emphasis: 'yellow' }));
+    }
+    else if (instance.completedAt) {
+        const value = formatTimestamp(instance.completedAt);
+        rows.push(formatKeyValue({ key: 'Completed', value, padTo: HEADER_PAD, emphasis: 'green' }));
     }
     else {
-        const completed = instance.completedAt
-            ? styleText('green', formatTimestamp(instance.completedAt))
-            : styleText('dim', '—');
-        rows.push(formatKeyValue({ key: 'Completed', value: completed, padTo: HEADER_PAD }));
+        const value = styleText('dim', '—');
+        rows.push(formatKeyValue({ key: 'Completed', value, padTo: HEADER_PAD }));
     }
     rows.push(formatKeyValue({ key: 'Tag', value: instance.tag, padTo: HEADER_PAD }));
     return [title, ...rows].join('\n');

package/dist/lib/context.d.ts

@@ -1,7 +1,6 @@
 import type { SanityClient } from '@sanity/client';
 import { type WorkflowConfig, type WorkflowDeployment, type WorkflowInstance, type WorkflowResource } from '@sanity/workflow-engine';
 import type { EngineScope } from './operation-args.ts';
-import { type ChooseDeploymentName } from './select-deployment.ts';
 export interface DeploymentContext {
     deployment: WorkflowDeployment;
     client: SanityClient;
@@ -51,20 +50,18 @@ export declare function dedupeResources(resources: WorkflowResource[]): Workflow
  *  tag (tags may repeat across deployments), or — untagged — every distinct
  *  one the config's deployments mention ({@link dedupeResources}). */
 export declare function resolveReadResources(config: WorkflowConfig, tag: string | undefined): WorkflowResource[];
-/** The single resource an instance-keyed command reads from when it isn't
- *  disambiguated interactively: the sole resource, the `--tag`-narrowed one, or
- *  a `fail` asking for `--deployment`/`--tag` when the config spans several. The
- *  interactive picker lives in {@link resolveInstanceResource}; listings fan out
- *  via {@link resolveReadResources} instead. */
-export declare function resolveReadResource(config: WorkflowConfig, tag: string | undefined): WorkflowResource;
 /**
- * The resolution an instance-id-targeted command shares, read or write: an
- * authenticated client for the resource, plus the instance itself — so the
- * command derives its partition (`tag`) from the instance, never from the
- * config's declared deployments. An instance id is globally unique and carries
- * its own `tag`, so a command that names one acts on that instance regardless
- * of which tags the config happens to deploy; the config only locates the
- * resource (via {@link resolveInstanceResource}, no tag filter).
+ * The resolution an instance-id-targeted command shares, read or write: locate
+ * the instance by the same cross-resource fan-out the read/list commands use
+ * ({@link findInstance}), then hand back an authenticated client for the
+ * resource that held it plus a scope whose `tag` comes from the instance
+ * itself — never from the config's declared deployments. An instance id is
+ * globally unique and carries its own `tag`, so naming one is enough to act on
+ * it: the config only locates candidate resources, and the fan-out's
+ * {@link soleHitOrFail} rejects the collision case where several datasets hold
+ * the id (the `<tag>.` fast-path may skip that full-set check — safe, ids are
+ * collision-free). `--deployment` / `--tag` stay optional narrowers, not
+ * required disambiguators.
  *
  * Contrast {@link resolveContext}: the deploy/diff/delete path IS scoped to a
  * declared deployment because it acts on the authored definition set (or a
@@ -74,29 +71,6 @@ export declare function resolveInstanceContext(flags: {
     deployment?: string | undefined;
     tag?: string | undefined;
 }, instanceId: string): Promise<InstanceContext>;
-/**
- * Which resource an instance-keyed command reads from: the one `--deployment`
- * names (resolved by its unique deployment name); otherwise, when the config
- * spans several resources, an interactive terminal is prompted to pick a
- * deployment ({@link canPromptOnStderr}) — its resource is the read source, the
- * interactive counterpart to `--deployment`. A run that can't prompt falls to
- * the sole or `--tag`-narrowed resource, or the ambiguity error
- * ({@link resolveReadResource}). The instance id is globally unique, so this
- * only locates the resource to look in — never the instance's `tag` partition,
- * which the caller takes from the loaded instance. The shared path behind all
- * four instance-keyed commands.
- */
-export declare function resolveInstanceResource(config: WorkflowConfig, { deployment, tag, interactive, chooseDeployment, }: {
-    deployment?: string | undefined;
-    tag?: string | undefined;
-    interactive?: boolean | undefined;
-    chooseDeployment?: ChooseDeploymentName | undefined;
-}): Promise<WorkflowResource>;
-/** Fetch an instance by id, exiting cleanly when the resource has no such
- *  document — the diagnostic an operator sees on a mistyped id. Split out from
- *  {@link resolveInstanceContext} so the not-found path is unit-testable
- *  without a live config/token/client. */
-export declare function loadInstanceOrFail(client: Pick<SanityClient, 'getDocument'>, instanceId: string): Promise<WorkflowInstance>;
 /** A read target that turned out to hold the instance being looked up. */
 export interface InstanceHit extends ReadTarget {
     instance: WorkflowInstance;

package/dist/lib/context.js

@@ -2,19 +2,20 @@ import { assertReadableModel, resourceGdr, } from '@sanity/workflow-engine';
 import { clientFor, resolveTokenOrFail } from "./client.js";
 import { fail } from "./fail.js";
 import { loadWorkflowConfig } from "./load-config.js";
-import { canPromptOnStderr } from "./prompt.js";
-import { availableDeployments, deploymentsForTag, selectDeployment, } from "./select-deployment.js";
+import { deploymentsForTag, selectDeployment } from "./select-deployment.js";
 import { resourceLabel } from "./ui.js";
 export async function resolveContext(flags) {
     const config = await loadWorkflowConfig();
     const deployment = await selectDeployment(config, { name: flags.deployment, tag: flags.tag });
     return { deployment, client: clientFor(deployment.workflowResource, await resolveTokenOrFail()) };
 }
+function targetsFor(resources, token) {
+    return resources.map((resource) => ({ resource, client: clientFor(resource, token) }));
+}
 export async function resolveReadTargets(flags) {
     const config = await loadWorkflowConfig();
     const resources = resolveReadResources(config, flags.tag);
-    const token = await resolveTokenOrFail();
-    return resources.map((resource) => ({ resource, client: clientFor(resource, token) }));
+    return targetsFor(resources, await resolveTokenOrFail());
 }
 export function dedupeResources(resources) {
     return [...new Map(resources.map((resource) => [resourceGdr(resource), resource])).values()];
@@ -29,50 +30,53 @@ export function resolveReadResources(config, tag) {
     }
     return resources;
 }
-export function resolveReadResource(config, tag) {
-    const resources = resolveReadResources(config, tag);
-    const [sole] = resources;
-    if (resources.length === 1 && sole !== undefined) {
-        return sole;
+const LOCATE_TAG = 'instance.load';
+export async function resolveInstanceContext(flags, instanceId) {
+    const config = await loadWorkflowConfig();
+    const token = await resolveTokenOrFail();
+    const hit = await locateInstance({ config, flags, instanceId, token });
+    if (hit === undefined) {
+        fail(`Workflow instance ${instanceId} not found`);
     }
-    if (tag === undefined) {
-        fail('Config spans multiple resources — pass --deployment or --tag to choose one.', availableDeployments(config));
+    return { client: hit.client, scope: { tag: hit.instance.tag, workflowResource: hit.resource } };
+}
+async function locateInstance({ config, flags, instanceId, token, }) {
+    const resources = await instanceCandidateResources(config, flags);
+    const fanOut = () => findInstance({ targets: targetsFor(resources, token), instanceId, requestTag: LOCATE_TAG });
+    const explicit = flags.deployment !== undefined || flags.tag !== undefined;
+    const hinted = explicit || resources.length <= 1
+        ? []
+        : hintedResources({ config, instanceId, candidates: resources });
+    if (hinted.length === 0 || hinted.length === resources.length) {
+        return fanOut();
     }
-    const carriers = config.deployments.filter((d) => d.tag === tag);
-    fail(`Tag "${tag}" spans multiple resources — pass --deployment to choose one.`, availableDeployments(config, carriers));
+    const hit = await hintedProbe(targetsFor(hinted, token), instanceId);
+    return hit ?? fanOut();
 }
-export async function resolveInstanceContext(flags, instanceId) {
-    const config = await loadWorkflowConfig();
-    const workflowResource = await resolveInstanceResource(config, flags);
-    const client = clientFor(workflowResource, await resolveTokenOrFail());
-    const instance = await loadInstanceOrFail(client, instanceId);
-    return { client, scope: { tag: instance.tag, workflowResource } };
+async function hintedProbe(targets, instanceId) {
+    try {
+        return await findInstance({ targets, instanceId, requestTag: LOCATE_TAG });
+    }
+    catch {
+        return undefined;
+    }
 }
-export async function resolveInstanceResource(config, { deployment, tag, interactive, chooseDeployment, }) {
+async function instanceCandidateResources(config, { deployment, tag }) {
     if (deployment !== undefined) {
-        return (await selectDeployment(config, { name: deployment, tag: undefined })).workflowResource;
-    }
-    if (tag === undefined &&
-        (interactive ?? canPromptOnStderr()) &&
-        resolveReadResources(config, undefined).length > 1) {
-        const chosen = await selectDeployment(config, {
-            name: undefined,
-            tag: undefined,
-            interactive: true,
-            chooseName: chooseDeployment,
-        });
-        return chosen.workflowResource;
+        return [(await selectDeployment(config, { name: deployment, tag: undefined })).workflowResource];
     }
-    return resolveReadResource(config, tag);
+    return resolveReadResources(config, tag);
 }
-export async function loadInstanceOrFail(client, instanceId) {
-    const instance = await client.getDocument(instanceId, {
-        tag: 'instance.load',
-    });
-    if (!instance) {
-        fail(`Workflow instance ${instanceId} not found`);
+function hintedResources({ config, instanceId, candidates, }) {
+    const dot = instanceId.indexOf('.');
+    if (dot <= 0) {
+        return [];
     }
-    return assertReadableModel(instance);
+    const prefix = instanceId.slice(0, dot);
+    const taggedGdrs = new Set(config.deployments
+        .filter((deployment) => deployment.tag === prefix)
+        .map((deployment) => resourceGdr(deployment.workflowResource)));
+    return candidates.filter((resource) => taggedGdrs.has(resourceGdr(resource)));
 }
 export function soleHitOrFail(hits, subject) {
     const [sole, ...rest] = hits;

package/dist/lib/flags.d.ts

@@ -7,13 +7,13 @@
 export declare const tagFlags: {
     tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };
-/** The selectors an instance-keyed command (`diagnose`, `abort`, `set-stage`,
- *  `fire-action`) takes. An instance id is globally unique and carries its own
- *  `tag`, so these only pick WHICH resource to read it from — never the
- *  instance's partition, which always comes from the loaded instance.
- *  `--deployment` names one deployment and reads from the resource it targets;
- *  `--tag` stays the optional narrower {@link tagFlags} describes. Mutually
- *  exclusive; a sole-resource config needs neither. */
+/** The optional narrowers an instance-keyed command (`diagnose`, `abort`,
+ *  `set-stage`, `fire-action`, `reset-activity`) takes. The command locates the
+ *  instance by fanning out across every configured resource, so neither is ever
+ *  required — an instance id is globally unique and carries its own `tag`. They
+ *  only narrow WHERE to look: `--deployment` to the resource one deployment
+ *  targets, `--tag` to the resources under that tag. The instance's partition
+ *  always comes from the loaded instance, never from these. Mutually exclusive. */
 export declare const instanceFlags: {
     deployment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -28,6 +28,11 @@ export declare const deploymentFlags: {
     deployment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };
+/** Structured stdout instead of the rendered view. One payload convention:
+ *  verb commands emit their operation envelope (`instanceId` carries the doc
+ *  `_id`); read commands emit document-shaped data — `show` commands print
+ *  the fetched document as stored, list commands print the table's row view
+ *  (plus each row's `resource`) under a `truncated` flag. */
 export declare const jsonFlags: {
     json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };

package/dist/lib/flags.js

@@ -1,11 +1,11 @@
 import { Flags } from '@oclif/core';
-const tagAsFilterDescription = 'Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.';
+const tagAsFilterDescription = 'Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.';
 export const tagFlags = {
     tag: Flags.string({ description: tagAsFilterDescription }),
 };
 export const instanceFlags = {
     deployment: Flags.string({
-        description: 'Deployment name — read the instance from the resource that deployment targets; the tag partition still comes from the loaded instance.',
+        description: 'Deployment name — narrow the instance search to the resource that deployment targets; the tag partition still comes from the loaded instance.',
         exclusive: ['tag'],
     }),
     tag: Flags.string({ description: tagAsFilterDescription, exclusive: ['deployment'] }),

package/dist/lib/read-fanout.d.ts

@@ -6,6 +6,29 @@ export interface ReadFailure {
     resource: WorkflowResource;
     message: string;
 }
+/**
+ * The `--json` tail of a list command — the structured counterpart of
+ * {@link runReadAcrossTargets} + the clipped table: fetch every target's
+ * rows, {@link clipToLimit} each target's page, map rows through the
+ * command's row view (`toRow`, the structured analogue of the table's
+ * `toCells`), annotate each with the resource it came from (the analogue of
+ * the banner), and log one `{<key>: rows, truncated}` payload.
+ * All-or-nothing, unlike the human path's per-resource tolerance: a script
+ * would mistake a listing that silently omitted an unreadable resource for
+ * the complete result, so any failure rejects the whole read.
+ */
+export declare function logJsonListing<T, R>({ targets, fetch, toRow, key, limit, log, }: {
+    targets: ReadTarget[];
+    fetch: (target: ReadTarget) => Promise<{
+        rows: T[];
+        hasMore: boolean;
+    }>;
+    toRow: (row: T) => R;
+    /** The payload's row key — names what the rows are (`instances`, `definitions`). */
+    key: string;
+    limit: number;
+    log: (line: string) => void;
+}): Promise<void>;
 /**
  * Run a read over every target, grouping output per resource: a banner when
  * the read spans several, then whatever `run` logs for that target. A throw

package/dist/lib/read-fanout.js

@@ -1,6 +1,22 @@
 import logSymbols from 'log-symbols';
 import { failureDetail } from "./fail.js";
-import { groupBanner, resourceLabel } from "./ui.js";
+import { clipToLimit, groupBanner, resourceLabel } from "./ui.js";
+export async function logJsonListing({ targets, fetch, toRow, key, limit, log, }) {
+    const fetched = await Promise.all(targets.map(async (target) => {
+        const { rows, hasMore } = await fetch(target);
+        return {
+            rows: clipToLimit(rows, limit).rows.map((row) => ({
+                ...toRow(row),
+                resource: target.resource,
+            })),
+            hasMore: hasMore || rows.length > limit,
+        };
+    }));
+    log(JSON.stringify({
+        [key]: fetched.flatMap((result) => result.rows),
+        truncated: fetched.some((result) => result.hasMore),
+    }, null, 2));
+}
 export async function runReadAcrossTargets({ targets, log, run, }) {
     const failures = [];
     for (const [index, target] of targets.entries()) {

package/dist/lib/select-deployment.d.ts

@@ -48,10 +48,6 @@ export declare function deploymentsForTag(config: WorkflowConfig, tag: string):
  * explicit opt-in — never a default.
  */
 export declare function selectDeployments(config: WorkflowConfig, { name, tag, allTags, interactive, chooseName }: DeploymentSelectionOptions): Promise<WorkflowDeployment[]>;
-/** The "Available deployments: name (tag), …" hint every ambiguity failure
- *  prints — one vocabulary across the write and instance-keyed paths, so a
- *  reader always sees both the `--deployment` names and their `--tag`s. */
-export declare function availableDeployments(config: WorkflowConfig, deployments?: WorkflowDeployment[]): string;
 /**
  * Project a deployment into the engine's {@link DeployTarget} — the shape the
  * deploy/diff verbs (`deployDefinitions`, `computeDiffEntries`, `diffEntry`)

package/dist/lib/select-deployment.js

@@ -66,7 +66,7 @@ async function chooseDeploymentName(deployments) {
         choices: deployments.map(({ name, tag }) => ({ name, value: name, description: `tag: ${tag}` })),
     });
 }
-export function availableDeployments(config, deployments = config.deployments) {
+function availableDeployments(config, deployments = config.deployments) {
     return `Available deployments: ${deployments.map(deploymentLabel).join(', ')}`;
 }
 export function deploymentToTarget(deployment) {

package/dist/lib/ui.d.ts

@@ -1,3 +1,4 @@
+import { styleText } from 'node:util';
 import type { ActivityStatus, WorkflowResource } from '@sanity/workflow-engine';
 /**
  * A bold `Title:` section heading. Mirrors the Sanity CLI's `sectionHeader`
@@ -8,12 +9,17 @@ export declare function sectionHeader(title: string): string;
  * A `  key:   value` detail row — a dim, padded key then the value. Mirrors
  * the Sanity CLI's `formatKeyValue` so it folds into the shared helper on
  * merge; pass `padTo` (the longest key's length) to align a block of rows.
+ *
+ * Pass `emphasis` (a {@link styleText} colour) to render the whole row — key
+ * and value together — bold in that colour instead of the dim-key default, so
+ * a standout row (a terminal instance status) pops from the neutral rows.
  */
-export declare function formatKeyValue({ key, value, indent, padTo, }: {
+export declare function formatKeyValue({ key, value, indent, padTo, emphasis, }: {
     key: string;
     value: string;
     indent?: number;
     padTo?: number;
+    emphasis?: Parameters<typeof styleText>[0];
 }): string;
 /**
  * A borderless column table as printable lines: cyan header row, every

package/dist/lib/ui.js

@@ -6,9 +6,13 @@ import logSymbols from 'log-symbols';
 export function sectionHeader(title) {
     return styleText('bold', `${title}:`);
 }
-export function formatKeyValue({ key, value, indent = 2, padTo = 0, }) {
+export function formatKeyValue({ key, value, indent = 2, padTo = 0, emphasis, }) {
     const paddedKey = `${key}:`.padEnd(padTo > 0 ? padTo + 1 : key.length + 1);
-    return `${' '.repeat(indent)}${styleText('dim', paddedKey)} ${value}`;
+    const pad = ' '.repeat(indent);
+    if (emphasis) {
+        return `${pad}${styleText('bold', styleText(emphasis, `${paddedKey} ${value}`))}`;
+    }
+    return `${pad}${styleText('dim', paddedKey)} ${value}`;
 }
 export function formatTable(headers, rows) {
     const width = (cell) => stripVTControlCharacters(cell).length;

package/oclif.manifest.json

@@ -18,7 +18,7 @@
       ],
       "flags": {
         "deployment": {
-          "description": "Deployment name — read the instance from the resource that deployment targets; the tag partition still comes from the loaded instance.",
+          "description": "Deployment name — narrow the instance search to the resource that deployment targets; the tag partition still comes from the loaded instance.",
           "exclusive": [
             "tag"
           ],
@@ -28,7 +28,7 @@
           "type": "option"
         },
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "exclusive": [
             "deployment"
           ],
@@ -165,7 +165,7 @@
       ],
       "flags": {
         "deployment": {
-          "description": "Deployment name — read the instance from the resource that deployment targets; the tag partition still comes from the loaded instance.",
+          "description": "Deployment name — narrow the instance search to the resource that deployment targets; the tag partition still comes from the loaded instance.",
           "exclusive": [
             "tag"
           ],
@@ -175,7 +175,7 @@
           "type": "option"
         },
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "exclusive": [
             "deployment"
           ],
@@ -225,7 +225,7 @@
       ],
       "flags": {
         "deployment": {
-          "description": "Deployment name — read the instance from the resource that deployment targets; the tag partition still comes from the loaded instance.",
+          "description": "Deployment name — narrow the instance search to the resource that deployment targets; the tag partition still comes from the loaded instance.",
           "exclusive": [
             "tag"
           ],
@@ -235,7 +235,7 @@
           "type": "option"
         },
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "exclusive": [
             "deployment"
           ],
@@ -299,11 +299,12 @@
         "<%= config.bin %> list --include-completed",
         "<%= config.bin %> list --definition productLaunch",
         "<%= config.bin %> list --document dataset:proj:ds:article-1",
-        "<%= config.bin %> list --tag prod"
+        "<%= config.bin %> list --tag prod",
+        "<%= config.bin %> list --json"
       ],
       "flags": {
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "name": "tag",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -342,6 +343,12 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "json": {
+          "description": "Emit structured JSON instead of rendered output.",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -429,8 +436,21 @@
         "<%= config.bin %> reset-activity wf-instance.abc123 legal-review --skip"
       ],
       "flags": {
+        "deployment": {
+          "description": "Deployment name — narrow the instance search to the resource that deployment targets; the tag partition still comes from the loaded instance.",
+          "exclusive": [
+            "tag"
+          ],
+          "name": "deployment",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
+          "exclusive": [
+            "deployment"
+          ],
           "name": "tag",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -476,7 +496,7 @@
       ],
       "flags": {
         "deployment": {
-          "description": "Deployment name — read the instance from the resource that deployment targets; the tag partition still comes from the loaded instance.",
+          "description": "Deployment name — narrow the instance search to the resource that deployment targets; the tag partition still comes from the loaded instance.",
           "exclusive": [
             "tag"
           ],
@@ -486,7 +506,7 @@
           "type": "option"
         },
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "exclusive": [
             "deployment"
           ],
@@ -540,18 +560,19 @@
       "description": "Show the state, activities, and effects of a workflow instance.",
       "examples": [
         "<%= config.bin %> show wf-instance.abc123",
-        "<%= config.bin %> show wf-instance.abc123 --include history"
+        "<%= config.bin %> show wf-instance.abc123 --include history",
+        "<%= config.bin %> show wf-instance.abc123 --json"
       ],
       "flags": {
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "name": "tag",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
         "include": {
-          "description": "Optional sections to include in output.",
+          "description": "Optional sections to include in rendered output (--json always carries the full document).",
           "name": "include",
           "default": [],
           "hasDynamicHelp": false,
@@ -560,6 +581,12 @@
             "history"
           ],
           "type": "option"
+        },
+        "json": {
+          "description": "Emit structured JSON instead of rendered output.",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -677,7 +704,7 @@
       ],
       "flags": {
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "name": "tag",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -843,11 +870,12 @@
       "description": "List deployed workflow definitions.",
       "examples": [
         "<%= config.bin %> definition list",
-        "<%= config.bin %> definition list --tag prod"
+        "<%= config.bin %> definition list --tag prod",
+        "<%= config.bin %> definition list --json"
       ],
       "flags": {
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "name": "tag",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -867,6 +895,12 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "json": {
+          "description": "Emit structured JSON instead of rendered output.",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -899,7 +933,7 @@
       "description": "Show a deployed workflow definition.",
       "flags": {
         "tag": {
-          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter, and the resource disambiguator when the config spans several.",
+          "description": "Workflow environment tag (e.g. prod, test) — an optional query filter that also narrows which resources are searched; omit to span them all.",
           "name": "tag",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -911,6 +945,12 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "json": {
+          "description": "Emit structured JSON instead of rendered output.",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -930,5 +970,5 @@
       ]
     }
   },
-  "version": "0.21.0"
+  "version": "0.22.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/workflow-cli",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Command-line tool for deploying, inspecting, and administering Sanity workflow definitions and instances.",
   "keywords": [
     "cli",
@@ -62,12 +62,12 @@
     "@types/node": "^24.12.4",
     "oclif": "^4.23.16",
     "vitest": "^4.1.8",
-    "@sanity/workflow-engine": "0.21.0",
-    "@sanity/workflow-engine-test": "0.21.0",
-    "@sanity/workflow-examples": "0.10.0"
+    "@sanity/workflow-engine": "0.22.0",
+    "@sanity/workflow-engine-test": "0.22.0",
+    "@sanity/workflow-examples": "0.10.1"
   },
   "peerDependencies": {
-    "@sanity/workflow-engine": "0.21.0"
+    "@sanity/workflow-engine": "0.22.0"
   },
   "oclif": {
     "bin": "sanity-workflows",