@sanity/workflow-cli 0.27.0 → 0.29.0

package/CHANGELOG.md

@@ -1,5 +1,64 @@
 # @sanity/workflow-cli
 
+## 0.29.0
+
+### Patch Changes
+
+- 8bb6a85: The workflow CLI README lists commands with operator-facing descriptions instead of implementation status.
+
+  **No upgrade action required.** Command behavior is unchanged.
+
+  **Docs impact:** `packages/workflow-cli` README — the former Command status table is now Command list.
+
+- 772876b: When this package is mounted inside the official `sanity` CLI, its telemetry prerun hook no longer installs a store for host commands outside the `workflows` topic (the finally hook already no-ops when telemetry was never installed). Previously every `sanity` command in a directory with a `sanity.workflow.ts` could load workflow config, show the workflow-cli disclosure, and emit an `Editorial Workflows CLI Command Executed` event for unrelated commands such as `sanity dataset list`. Standalone `sanity-workflows` behaviour is unchanged.
+
+  **No upgrade action required** for standalone users. Hosts that already mount this package as an oclif plugin pick up the safer hook scope on upgrade — no config change.
+
+  **Docs impact:** None — host-mount telemetry scoping only; documented invoke paths are unchanged.
+
+- 772876b: The `workflows` topic help description no longer uses an em dash. It now reads "Deploy, inspect, and administer Editorial Workflows definitions and instances", matching the plain phrasing of other product CLI topics.
+
+  **No upgrade action required.**
+
+  **Docs impact:** None — help copy only; documented invoke paths are unchanged.
+
+- Updated dependencies [f44fc33]
+- Updated dependencies [26f25e0]
+- Updated dependencies [25bd1fb]
+- Updated dependencies [3fd04f1]
+  - @sanity/workflow-engine@0.29.0
+
+## 0.28.0
+
+### Minor Changes
+
+- 5050b06: **BREAKING:** Authoring a deployment now types through `WorkflowDeploymentInput` / `WorkflowConfigInput`, which require `expectedMinReaderModel` as the current reader-floor literal. Passing a parsed `WorkflowDeployment` / `WorkflowConfig` (where the floor is optional/unverified) into `defineWorkflowConfig` or `defineWorkflows` is a type error — share the authored deployment object instead of `config.deployments[n]`. The same pin shows up on the blueprint resource: `EditorialWorkflowsResource.deployment` and `parseWorkflowDeployment`'s return type are now `AcknowledgedDeployment` (floor asserted to the current literal), so a hand-constructed provider resource must carry that literal too.
+
+  At runtime, config parse no longer rejects a stale or missing floor on an untargeted deployment. Only deployment-scoped commands assert, and only the selected deployment: definition deploy, `--check` / `--dry-run`, blueprint provision, `start`, `definition delete`, and `definition diff` (the last is a deployment-scoped read). Instance-id commands (`fire-action`, `abort`, `set-stage`, `reset-activity`) deliberately do not assert — they resolve by instance id, not by a declared deployment's acknowledgement — so an unacknowledged floor does not stop those instance commits.
+
+  Upgrade TypeScript configs and blueprint manifests that fed a parsed deployment into those helpers: keep a shared authored object (`satisfies WorkflowDeploymentInput`) for both `defineWorkflowConfig` and `defineWorkflows`, and give any hand-built `EditorialWorkflowsResource` the current floor literal on `deployment`. Existing configs that already acknowledge the current floor keep working at runtime; a stale selected deployment still fails with `ReaderModelAcknowledgementError` (headline + short steps; the CLI renders it through the clean styled-error path).
+
+  **Docs impact:** Update the CLI / blueprint authoring examples and the prerelease reader-floor guidance so they name `WorkflowConfigInput` / `WorkflowDeploymentInput` / `AcknowledgedDeployment`, forbid passing `config.deployments[n]` into `defineWorkflows`, state that instance-id writes are outside the acknowledgement gate, and stop implying whole-config parse-time rejection for commands that never select a deployment.
+
+- cc50d58: **BREAKING:** Canonical oclif command ids move from the `editorial-workflows` topic to `workflows`. A future host mount therefore surfaces `sanity workflows deploy` (and the same shape for every other command) instead of `sanity editorial-workflows …`. Standalone short forms (`sanity-workflows deploy`, `definition list`, …) are unchanged — the bin still rewrites them onto the topic before resolution.
+
+  Anyone invoking the previous topic-scoped ids (`sanity-workflows editorial-workflows deploy`, or a host/plugin that hard-coded those ids) must switch to `workflows …`. Continuing to call `editorial-workflows …` fails with command-not-found.
+
+  **Docs impact:** When the host mount ships, update Editorial Workflows CLI getting-started and invocation docs so the documented host path is `sanity workflows …`, and refresh any topic-scoped examples that still say `editorial-workflows`. Until then the standalone short forms remain the documented surface.
+
+### Patch Changes
+
+- 4403e66: Short command forms (`deploy`, `definition list`, …) are no longer registered as oclif root aliases. The standalone `sanity-workflows` binary still accepts those forms by rewriting argv onto the `workflows` topic before command resolution, so day-to-day usage is unchanged. Removing the aliases makes the package safe to mount inside the official `sanity` CLI without colliding with host commands such as `sanity deploy`.
+
+  **No upgrade action required** for standalone `sanity-workflows` / `npx @sanity/workflow-cli` users. Anyone who embedded this package as an oclif plugin and relied on the root aliases must invoke the topic-scoped ids (`workflows deploy`, …) or perform equivalent argv rewriting in the host.
+
+  **Docs impact:** Update Editorial Workflows CLI getting-started and invocation docs when the host mount ships so the primary path is `sanity workflows …`; until then the standalone short forms remain the documented surface in this package README.
+
+- Updated dependencies [1e4a5da]
+- Updated dependencies [5050b06]
+- Updated dependencies [a044ba5]
+  - @sanity/workflow-engine@0.28.0
+
 ## 0.27.0
 
 ### Patch Changes

package/README.md

@@ -21,17 +21,16 @@ pnpm --filter @sanity/workflow-cli dev show wf-instance.abc123
 ```
 
 The package is an [oclif](https://oclif.io) plugin: every command's canonical
-id nests under the `editorial-workflows` topic
-(`sanity-workflows editorial-workflows deploy`), so mounting the package into
+id nests under the `workflows` topic
+(`sanity-workflows workflows deploy`), so mounting the package into
 the `sanity` CLI's plugin list surfaces the same commands as
-`sanity editorial-workflows …` without its canonical ids colliding with the
-host's own commands (the sanity CLI already has a `deploy`). The bare forms
-used throughout this README (`deploy`, `definition list`, …) are aliases of
-the nested ids and are the standalone binary's stable surface. oclif registers
-plugin aliases in a host unconditionally (an id collision resolves by plugin
-priority, host first), so a host mount would also surface these bare aliases
-at its root — trimming or hiding them for the mounted context is part of the
-host-side mount work, not something a host can configure away.
+`sanity workflows …` without colliding with the host's own root
+commands (the sanity CLI already has a `deploy`). The short forms used
+throughout this README (`deploy`, `definition list`, …) are the standalone
+binary's stable surface — its production and development entrypoints
+(`bin/run.js` and `bin/dev.js`) rewrite them onto the topic before oclif
+resolves the command. Those short forms are **not** registered as oclif aliases,
+so a host mount does not pollute the host root.
 
 Authenticate once with `sanity login` (the CLI reads that session token); for
 CI, set `SANITY_AUTH_TOKEN` instead. Then create a `sanity.workflow.ts` in the
@@ -154,30 +153,32 @@ stale compiled output.
 > `--dry-run` and `--only` don't collide with pnpm flags and work
 > through the normal `pnpm --filter … dev …` invocation.
 
-## Command status
-
-| Command                                         | Status                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `deploy`                                        | wired — calls `workflow.deployDefinitions` over the selected deployment's definitions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `deploy --all-tags`                             | wired — deploys every deployment in the config, continuing past per-deployment failures                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `deploy --check`                                | wired — runs `validateDefinition` over the local batch + a duplicate-name check                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `deploy --dry-run`                              | wired — fetches existing docs and renders a coloured JSON diff per change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `deploy --only <name>`                          | wired — filters deploy/check/dry-run to one definition by `name`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `start <name>`                                  | wired — calls `workflow.startInstance` (`--field` for input fields)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `list`                                          | wired — `client.fetch` over `sanity.workflow.instance` documents (`--definition <name>` to filter)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `show <instance-id>`                            | wired — `client.getDocument`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `diagnose <instance-id>`                        | wired — calls `workflow.diagnose`, classifies why the instance is/isn't progressing                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `tail <instance-id>`                            | wired — `client.listen()` over the instance, prints new history entries                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `abort <instance-id>`                           | wired — calls `workflow.abortInstance` (hard stop: cancels pending effects, removes guards)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `set-stage <instance-id> --to <stage>`          | wired — calls `workflow.setStage` (admin override: skips declared transitions/filters; enter lifecycle + cascade still run)                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `reset-activity <instance-id> <activity>`       | wired — calls `workflow.resetActivity` (recovery override: reset a failed activity to `active`, or `--skip` to bypass it; then cascade)                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `fire-action <instance-id>`                     | wired — `workflow.availableActions` lists actions; `workflow.fireAction` fires one                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `definition list`                               | wired — `client.fetch` over `sanity.workflow.definition` documents                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `definition show <name>`                        | wired — `client.fetch`, latest version unless `--version`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `definition diff <name>`                        | wired — diffs the in-code definition against the deployed latest (`--version` to pin)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `definition delete <name>`                      | wired — calls `workflow.deleteDefinition` (refuses on live instances unless `--cascade`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `nuke --deployment <name>` / `nuke --tag <tag>` | wired — dev-period reset (exists only until the versioned upgrade framework): deletes every engine-owned doc for the deployment's tag (instances, definitions, guards across resources); exactly one of these two selectors required; refuses while another same-tag deployment sweeps an overlapping resource (guard ids embed only the tag); plan + typed confirm                                                                                                                                                                                                                  |
-| `nuke --instance <id>`                          | wired — dev-period reset, same fence as the tag mode above: deletes ONE terminal instance plus the guards it owns, swept across every alias-bound resource (matched by `sourceInstanceId`, with an id-prefix leg as redundant cover; matching provenance rather than the live instance set is what catches a partial-delete orphan); definitions are never in scope; refuses an in-flight instance (abort it first) and anything that is not an engine instance document; takes no `--tag`, and `--deployment` only to disambiguate a tag spanning deployments; plan + `y/N` confirm |
+## Command list
+
+Invoke as `sanity-workflows <command>` (or `sanity workflows <command>` once the host CLI mount lands).
+
+| Command                                         | Description                                                                                                                                                                  |
+| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `deploy`                                        | Validate and deploy the definitions in the selected deployment.                                                                                                              |
+| `deploy --all-tags`                             | Deploy every deployment in the config. A failure in one does not stop the rest.                                                                                              |
+| `deploy --check`                                | Validate local definitions without contacting the dataset.                                                                                                                   |
+| `deploy --dry-run`                              | Show a diff against what is already deployed, without writing.                                                                                                               |
+| `deploy --only <name>`                          | Limit deploy, check, or dry-run to one definition.                                                                                                                           |
+| `start <name>`                                  | Start an instance from a deployed definition. Pass `--field` for input values.                                                                                               |
+| `list`                                          | List instances (in-flight by default). Filter with `--definition`.                                                                                                           |
+| `show <instance-id>`                            | Show an instance's state, activities, and effects.                                                                                                                           |
+| `diagnose <instance-id>`                        | Explain why an instance is or isn't progressing, and what would unstick it.                                                                                                  |
+| `tail <instance-id>`                            | Stream new history entries as they land.                                                                                                                                     |
+| `abort <instance-id>`                           | Stop an in-flight instance. Pending effects cancel; the instance stays where it is.                                                                                          |
+| `set-stage <instance-id> --to <stage>`          | Move an instance to a stage, skipping declared transitions. The target stage's enter lifecycle still runs.                                                                   |
+| `reset-activity <instance-id> <activity>`       | Re-run a failed activity, or `--skip` it so a gated transition can fire.                                                                                                     |
+| `fire-action <instance-id>`                     | Fire an action on a waiting activity. Omit `--action` to list what can be fired.                                                                                             |
+| `definition list`                               | List deployed definitions.                                                                                                                                                   |
+| `definition show <name>`                        | Show a deployed definition (latest version, or `--version`).                                                                                                                 |
+| `definition diff <name>`                        | Diff the in-code definition against what is deployed.                                                                                                                        |
+| `definition delete <name>`                      | Delete a deployed definition. Refuses while live instances exist unless `--cascade`.                                                                                         |
+| `nuke --deployment <name>` / `nuke --tag <tag>` | Dev reset: delete every engine-owned document for that tag (instances, definitions, guards). Prints a plan, then asks for confirmation. Content documents are never touched. |
+| `nuke --instance <id>`                          | Dev reset: delete one finished instance and its guards. Refuses in-flight instances (abort first).                                                                           |
 
 ## Telemetry
 
@@ -224,11 +225,11 @@ only warns, never failing a completed deploy.
 ## Known gaps
 
 - **Not mounted in the `sanity` CLI yet.** The package side is mount-ready —
-  commands nest under the `editorial-workflows` oclif topic (see
-  [Run](#run)) — but the `sanity` CLI does not list this package in its
-  plugin array, so the commands ship only through the standalone
-  `sanity-workflows` binary today. The host-side mount (and what happens to
-  the bare aliases inside a host) is a separate piece of work.
+  commands nest under the `workflows` oclif topic with no root
+  aliases (see [Run](#run)) — but the `sanity` CLI does not list this package
+  in its plugin array, so the commands ship only through the standalone
+  `sanity-workflows` binary today. The host-side mount is a separate piece of
+  work.
 - **No true bypass.** `set-stage` is the engine's `setStage` admin
   override: it skips the definition's declared transitions and filters, but
   the target stage's enter lifecycle and the post-move cascade still run. A

package/bin/run.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
 import {execute} from '@oclif/core'
 
-await execute({dir: import.meta.url})
+import {rewriteStandaloneArgv} from '../dist/standalone-argv.js'
+
+await execute({args: rewriteStandaloneArgv(process.argv.slice(2)), dir: import.meta.url})

package/dist/command-ids.d.ts

@@ -0,0 +1,10 @@
+export declare const WORKFLOWS_TOPIC = "workflows";
+export declare const WORKFLOWS_TOPIC_PREFIX = "workflows:";
+export declare const WORKFLOWS_DEPLOY_COMMAND_ID = "workflows:deploy";
+/** Standalone binary name from package.json `oclif.bin` / `bin`. */
+export declare const STANDALONE_BIN = "sanity-workflows";
+/** True on `sanity-workflows`, or on a host only for `workflows` / `workflows:*`. */
+export declare function shouldRunWorkflowCliTelemetry(args: {
+    bin: string;
+    commandId: string | undefined;
+}): boolean;

package/dist/command-ids.js

@@ -0,0 +1,10 @@
+export const WORKFLOWS_TOPIC = 'workflows';
+export const WORKFLOWS_TOPIC_PREFIX = `${WORKFLOWS_TOPIC}:`;
+export const WORKFLOWS_DEPLOY_COMMAND_ID = `${WORKFLOWS_TOPIC}:deploy`;
+export const STANDALONE_BIN = 'sanity-workflows';
+export function shouldRunWorkflowCliTelemetry(args) {
+    const { bin, commandId } = args;
+    return (bin === STANDALONE_BIN ||
+        commandId === WORKFLOWS_TOPIC ||
+        commandId?.startsWith(WORKFLOWS_TOPIC_PREFIX) === true);
+}

package/dist/commands/{editorial-workflows → workflows}/abort.d.ts

@@ -2,7 +2,6 @@ import { type WorkflowInstance } from '@sanity/workflow-engine';
 import { WorkflowCommand } from '../../lib/base-command.ts';
 import { type WriteReport } from '../../lib/ops-report.ts';
 export default class Abort extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{editorial-workflows → workflows}/abort.js

@@ -7,11 +7,10 @@ import { instanceFlags } from "../../lib/flags.js";
 import { buildOperationArgs } from "../../lib/operation-args.js";
 import { runWriteVerb } from "../../lib/ops-report.js";
 export default class Abort extends WorkflowCommand {
-    static aliases = ['abort'];
     static description = 'Abort an in-flight workflow instance — a hard stop: pending effects are cancelled, stage guards removed, and the instance is marked terminal where it stands.';
     static examples = [
-        '<%= config.bin %> abort wf-instance.abc123',
-        "<%= config.bin %> abort wf-instance.abc123 --reason 'superseded by relaunch'",
+        '<%= config.bin %> workflows abort wf-instance.abc123',
+        "<%= config.bin %> workflows abort wf-instance.abc123 --reason 'superseded by relaunch'",
     ];
     static args = {
         instanceId: Args.string({ required: true, description: 'Workflow instance id.' }),

package/dist/commands/{editorial-workflows → workflows}/definition/delete.d.ts

@@ -2,7 +2,6 @@ import { type DeleteDefinitionArgs, type DeleteDefinitionResult } from '@sanity/
 import { WorkflowCommand } from '../../../lib/base-command.ts';
 import { type EngineScope } from '../../../lib/operation-args.ts';
 export default class DefinitionDelete extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{editorial-workflows → workflows}/definition/delete.js

@@ -7,14 +7,13 @@ import { deploymentFlags } from "../../../lib/flags.js";
 import { baseEngineArgs } from "../../../lib/operation-args.js";
 import { runWriteVerb } from "../../../lib/ops-report.js";
 export default class DefinitionDelete extends WorkflowCommand {
-    static aliases = ['definition:delete'];
     static description = 'Delete a deployed workflow definition (every version, or one via --version). ' +
         'Refuses while non-terminal instances exist unless --cascade aborts them first — ' +
         'instances are aborted in place, never deleted.';
     static examples = [
-        '<%= config.bin %> definition delete my-workflow',
-        '<%= config.bin %> definition delete my-workflow --version 2',
-        "<%= config.bin %> definition delete my-workflow --cascade --reason 'workflow retired'",
+        '<%= config.bin %> workflows definition delete my-workflow',
+        '<%= config.bin %> workflows definition delete my-workflow --version 2',
+        "<%= config.bin %> workflows definition delete my-workflow --cascade --reason 'workflow retired'",
     ];
     static args = {
         name: Args.string({ required: true, description: 'Workflow definition name.' }),

package/dist/commands/{editorial-workflows → workflows}/definition/diff.d.ts

@@ -1,7 +1,6 @@
 import { type WorkflowDefinition } from '@sanity/workflow-engine';
 import { WorkflowCommand } from '../../../lib/base-command.ts';
 export default class DefinitionDiff extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{editorial-workflows → workflows}/definition/diff.js

@@ -8,11 +8,10 @@ import { diffReport } from "../../../lib/diff.js";
 import { deploymentFlags } from "../../../lib/flags.js";
 import { deploymentToTarget } from "../../../lib/select-deployment.js";
 export default class DefinitionDiff extends WorkflowCommand {
-    static aliases = ['definition:diff'];
     static description = 'Diff an in-code definition against the deployed version (latest by default).';
     static examples = [
-        '<%= config.bin %> definition diff productLaunch',
-        '<%= config.bin %> definition diff productLaunch --version 2',
+        '<%= config.bin %> workflows definition diff productLaunch',
+        '<%= config.bin %> workflows definition diff productLaunch --version 2',
     ];
     static args = {
         name: Args.string({ required: true, description: 'Workflow definition name.' }),

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

@@ -22,7 +22,6 @@ export declare function buildDefinitionListQuery(flags: DefinitionListFlags): {
     params: Record<string, unknown>;
 };
 export default class DefinitionList extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static flags: {

package/dist/commands/{editorial-workflows → workflows}/definition/list.js

@@ -40,12 +40,11 @@ export function buildDefinitionListQuery(flags) {
     return { groq, params };
 }
 export default class DefinitionList extends WorkflowCommand {
-    static aliases = ['definition:list'];
     static description = 'List deployed workflow definitions.';
     static examples = [
-        '<%= config.bin %> definition list',
-        '<%= config.bin %> definition list --tag prod',
-        '<%= config.bin %> definition list --json',
+        '<%= config.bin %> workflows definition list',
+        '<%= config.bin %> workflows definition list --tag prod',
+        '<%= config.bin %> workflows definition list --json',
     ];
     static flags = {
         ...tagFlags,

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

@@ -2,7 +2,6 @@ import { type DeployedDefinition, type WorkflowDefinition, type WorkflowResource
 import { WorkflowCommand } from '../../../lib/base-command.ts';
 import { type ReadTarget } from '../../../lib/context.ts';
 export default class DefinitionShow extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;

package/dist/commands/{editorial-workflows → workflows}/definition/show.js

@@ -9,7 +9,6 @@ import { fail } from "../../../lib/fail.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'];
     static description = 'Show a deployed workflow definition.';
     static args = {
         name: Args.string({ required: true, description: 'Workflow definition name.' }),

package/dist/commands/{editorial-workflows → workflows}/deploy.d.ts

@@ -12,7 +12,6 @@ interface DeployFailure {
     message: string;
 }
 export default class Deploy extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static flags: {
@@ -47,8 +46,10 @@ export declare function resolveBatches(config: WorkflowConfig, { only, selection
  * Select and validate every deployment's definitions up front. Validation runs
  * before any network write ({@link validateOrFail} exits on a bad definition),
  * so a whole-config deploy can never leave a partial reconcile behind a broken
- * batch. In a multi-deployment run the failure names its deployment — it exits
- * before any banner could attribute it.
+ * batch. Also asserts each selected deployment's reader-floor acknowledgement —
+ * including `--check`, which never reaches {@link deploymentToTarget}. In a
+ * multi-deployment run the failure names its deployment — it exits before any
+ * banner could attribute it.
  */
 export declare function buildBatches(deployments: WorkflowDeployment[], only: string | undefined): DeployBatch[];
 /**

package/dist/commands/{editorial-workflows → workflows}/deploy.js

@@ -1,6 +1,6 @@
 import { styleText } from 'node:util';
 import { Flags } from '@oclif/core';
-import { computeDiffEntries, errorMessage, workflow, } from '@sanity/workflow-engine';
+import { assertReaderModelAcknowledgement, computeDiffEntries, errorMessage, workflow, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
 import ora from 'ora';
 import { WorkflowCommand } from "../../lib/base-command.js";
@@ -15,15 +15,14 @@ import { shareDefinitionsAfterDeploy } from "../../lib/share-definitions.js";
 import { cliTelemetry } from "../../lib/telemetry.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.';
     static examples = [
-        '<%= config.bin %> deploy --deployment review-prod',
-        '<%= config.bin %> deploy --tag prod',
-        '<%= config.bin %> deploy --all-tags',
-        '<%= config.bin %> deploy --check',
-        '<%= config.bin %> deploy --dry-run',
-        '<%= config.bin %> deploy --only productLaunch',
+        '<%= config.bin %> workflows deploy --deployment review-prod',
+        '<%= config.bin %> workflows deploy --tag prod',
+        '<%= config.bin %> workflows deploy --all-tags',
+        '<%= config.bin %> workflows deploy --check',
+        '<%= config.bin %> workflows deploy --dry-run',
+        '<%= config.bin %> workflows deploy --only productLaunch',
     ];
     static flags = {
         ...deploymentFlags,
@@ -161,6 +160,7 @@ export async function resolveBatches(config, { only, selection }) {
 }
 export function buildBatches(deployments, only) {
     return deployments.map((deployment) => {
+        assertReaderModelAcknowledgement(deployment.expectedMinReaderModel, `Deployment ${deployment.name}`);
         const context = deployments.length > 1 ? `${deploymentLabel(deployment)} — ` : '';
         const defs = selectDefinitions(deployment.definitions, { only, context });
         validateOrFail(defs, context);
@@ -193,7 +193,13 @@ export function deploySummary({ total, failures, }) {
     return [
         '',
         styleText('bold', `${total - failures.length} of ${total} deployments succeeded — ${failures.length} failed:`),
-        ...failures.map((f) => styleText('red', `  ${logSymbols.error} ${deploymentLabel(f.deployment)} — ${f.message}`)),
+        ...failures.flatMap((f) => {
+            const [first = '', ...rest] = f.message.split('\n');
+            return [
+                styleText('red', `  ${logSymbols.error} ${deploymentLabel(f.deployment)} — ${first}`),
+                ...rest.map((line) => styleText('red', `    ${line}`)),
+            ];
+        }),
     ];
 }
 export function deploymentBanner({ deployment, index, total, }) {

package/dist/commands/{editorial-workflows → workflows}/diagnose.d.ts

@@ -32,7 +32,6 @@ export declare function renderDiagnosis({ diagnosis, input, remediations, explan
     explanations?: ReadonlyMap<string, string> | undefined;
 }): string[];
 export default class Diagnose extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{editorial-workflows → workflows}/diagnose.js

@@ -212,12 +212,11 @@ export function renderDiagnosis({ diagnosis, input, remediations, explanations,
     return lines;
 }
 export default class Diagnose extends WorkflowCommand {
-    static aliases = ['diagnose'];
     static description = "Explain why a workflow instance is or isn't progressing, and what would unstick it.";
     static examples = [
-        '<%= config.bin %> diagnose wf-instance.abc123',
-        '<%= config.bin %> diagnose wf-instance.abc123 --tag prod',
-        '<%= config.bin %> diagnose wf-instance.abc123 --json',
+        '<%= config.bin %> workflows diagnose wf-instance.abc123',
+        '<%= config.bin %> workflows diagnose wf-instance.abc123 --tag prod',
+        '<%= config.bin %> workflows diagnose wf-instance.abc123 --json',
     ];
     static args = {
         instanceId: Args.string({ required: true, description: 'Workflow instance id.' }),

package/dist/commands/{editorial-workflows → workflows}/fire-action.d.ts

@@ -30,7 +30,6 @@ export declare function fireActionReport({ result, activity, action, }: {
     action: string;
 }): WriteReport;
 export default class FireAction extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{editorial-workflows → workflows}/fire-action.js

@@ -82,12 +82,11 @@ export function fireActionReport({ result, activity, action, }) {
     };
 }
 export default class FireAction extends WorkflowCommand {
-    static aliases = ['fire-action'];
     static description = 'Fire an action on an instance to unstick a waiting activity — the write acts as the configured token. Omit --action to list what can be fired.';
     static examples = [
-        '<%= config.bin %> fire-action wf-instance.abc123',
-        '<%= config.bin %> fire-action wf-instance.abc123 --activity approve --action approve',
-        '<%= config.bin %> fire-action wf-instance.abc123 --activity publish --action publish --param note=shipping',
+        '<%= config.bin %> workflows fire-action wf-instance.abc123',
+        '<%= config.bin %> workflows fire-action wf-instance.abc123 --activity approve --action approve',
+        '<%= config.bin %> workflows fire-action wf-instance.abc123 --activity publish --action publish --param note=shipping',
     ];
     static args = {
         instanceId: Args.string({ required: true, description: 'Workflow instance id.' }),

package/dist/commands/{editorial-workflows → workflows}/list.d.ts

@@ -47,7 +47,6 @@ export declare function instanceRow(r: InstanceRow): {
     lastChangedAt: string;
 };
 export default class List extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static flags: {

package/dist/commands/{editorial-workflows → workflows}/list.js

@@ -77,15 +77,14 @@ export function instanceRow(r) {
     };
 }
 export default class List extends WorkflowCommand {
-    static aliases = ['list'];
     static description = 'List workflow instances in the configured dataset (in-flight by default).';
     static examples = [
-        '<%= config.bin %> list',
-        '<%= 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 --json',
+        '<%= config.bin %> workflows list',
+        '<%= 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 --tag prod',
+        '<%= config.bin %> workflows list --json',
     ];
     static flags = {
         ...tagFlags,

package/dist/commands/{editorial-workflows → workflows}/nuke.d.ts

@@ -1,7 +1,6 @@
 import { type WorkflowConfig, type WorkflowDeployment, type WorkflowInstance, type WorkflowResource } from '@sanity/workflow-engine';
 import { WorkflowCommand } from '../../lib/base-command.ts';
 export default class Nuke extends WorkflowCommand {
-    static aliases: string[];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/{editorial-workflows → workflows}/nuke.js

@@ -16,7 +16,6 @@ function planApiHost() {
     return resolveApiHost() ?? 'https://api.sanity.io (production default)';
 }
 export default class Nuke extends WorkflowCommand {
-    static aliases = ['nuke'];
     static summary = 'Delete engine-owned documents — a whole deployment tag, or a single instance.';
     static description = 'The reset for a dataset holding engine documents the versioned upgrade framework cannot yet ' +
         "migrate: deletes the tag's instances, definitions, and guards (across every alias-bound " +
@@ -24,9 +23,9 @@ export default class Nuke extends WorkflowCommand {
         'documents are never touched. Prints a dry-run plan, then confirms (--force skips the prompt; ' +
         'the plan still prints).';
     static examples = [
-        '<%= config.bin %> nuke --deployment plugin-dev',
-        '<%= config.bin %> nuke --tag plugin-dev --force',
-        '<%= config.bin %> nuke --instance plugin-dev.wf-instance.abc123',
+        '<%= config.bin %> workflows nuke --deployment plugin-dev',
+        '<%= config.bin %> workflows nuke --tag plugin-dev --force',
+        '<%= config.bin %> workflows nuke --instance plugin-dev.wf-instance.abc123',
     ];
     static flags = {
         deployment: Flags.string({

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

@@ -2,7 +2,6 @@ import { type ResetActivityTarget, type WorkflowInstance } from '@sanity/workflo
 import { WorkflowCommand } from '../../lib/base-command.ts';
 import { type WriteOutcome, type WriteReport } from '../../lib/ops-report.ts';
 export default class ResetActivity extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{editorial-workflows → workflows}/reset-activity.js

@@ -7,11 +7,10 @@ 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 {
-    static aliases = ['reset-activity'];
     static description = 'Reset a failed activity on an in-flight instance — back to active to re-run it, or --skip to bypass it (mark it skipped) so a gated exit transition can fire.';
     static examples = [
-        '<%= config.bin %> reset-activity wf-instance.abc123 legal-review',
-        '<%= config.bin %> reset-activity wf-instance.abc123 legal-review --skip',
+        '<%= config.bin %> workflows reset-activity wf-instance.abc123 legal-review',
+        '<%= config.bin %> workflows reset-activity wf-instance.abc123 legal-review --skip',
     ];
     static args = {
         instanceId: Args.string({ required: true, description: 'Workflow instance id.' }),

package/dist/commands/{editorial-workflows → workflows}/set-stage.d.ts

@@ -3,7 +3,6 @@ import { WorkflowCommand } from '../../lib/base-command.ts';
 import { type EngineScope } from '../../lib/operation-args.ts';
 import { type WriteOutcome, type WriteReport } from '../../lib/ops-report.ts';
 export default class SetStage extends WorkflowCommand {
-    static aliases: string[];
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{editorial-workflows → workflows}/set-stage.js

@@ -9,12 +9,11 @@ import { buildOperationArgs } from "../../lib/operation-args.js";
 import { cascadeTail, opsAppliedLines, runWriteVerb, } from "../../lib/ops-report.js";
 import { canPromptOnStderr, selectOnStderr } from "../../lib/prompt.js";
 export default class SetStage extends WorkflowCommand {
-    static aliases = ['set-stage'];
     static description = "Force an instance into a stage, regardless of its declared transitions and filters — the engine's setStage admin override. The target stage's enter lifecycle still runs (auto-activities start, stage guards reconcile), and the post-move cascade can immediately auto-transition the instance onward.";
     static examples = [
-        '<%= config.bin %> set-stage wf-instance.abc123 --to ready',
-        '<%= config.bin %> set-stage wf-instance.abc123',
-        "<%= config.bin %> set-stage wf-instance.abc123 --to ready --reason 'unblock for demo'",
+        '<%= config.bin %> workflows set-stage wf-instance.abc123 --to ready',
+        '<%= config.bin %> workflows set-stage wf-instance.abc123',
+        "<%= config.bin %> workflows set-stage wf-instance.abc123 --to ready --reason 'unblock for demo'",
     ];
     static args = {
         instanceId: Args.string({