@sanity/workflow-cli 0.9.0 → 0.11.0

package/dist/commands/diagnose.js

@@ -1,10 +1,12 @@
 import { styleText } from 'node:util';
-import { Args, Command } from '@oclif/core';
-import { diagnoseInputFromEvaluation, workflow, } from '@sanity/workflow-engine';
+import { Args } from '@oclif/core';
+import { diagnoseInputFromEvaluation, workflow, unsatisfiedTransitionSummaries, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
+import { WorkflowCommand } from "../lib/base-command.js";
 import { resolveInstanceContext } from "../lib/context.js";
-import { errorMessage, fail } from "../lib/fail.js";
+import { fail, failureDetail } from "../lib/fail.js";
 import { jsonFlags, tagFlags } from "../lib/flags.js";
+import { baseEngineArgs } from "../lib/operation-args.js";
 import { formatTimestamp, sectionHeader, activityIcon } from "../lib/ui.js";
 import { instanceHeader } from "./show.js";
 function formatAssignee(a) {
@@ -16,22 +18,23 @@ function activityLine(t, assignees) {
         : '';
     return `  ${activityIcon[t.status]} ${t.activity.name} ${styleText('dim', `[${t.status}]`)}${who}`;
 }
-function transitionLine(tr) {
-    const mark = tr.filterSatisfied ? styleText('green', 'ready') : styleText('red', 'false');
-    return `  → ${tr.transition.to}  ${styleText('dim', tr.transition.filter ?? 'true')}  ${mark}`;
+function transitionLine(tr, explanation) {
+    const mark = tr.whenSatisfied ? styleText('green', 'ready') : styleText('red', 'false');
+    const line = `  → ${tr.transition.to}  ${styleText('dim', tr.transition.when)}  ${mark}`;
+    return explanation !== undefined ? `${line}\n      ${styleText('dim', `↳ ${explanation}`)}` : line;
 }
-function currentStageLines(input) {
+function currentStageLines(input, explanations) {
     const lines = [
         `${sectionHeader('Stage')} ${input.instance.currentStage}`,
         sectionHeader('Activities'),
     ];
-    for (const t of input.activities) {
+    for (const t of input.activities.filter((a) => !a.scopedOut)) {
         lines.push(activityLine(t, input.assignees[t.activity.name] ?? []));
     }
     if (input.transitions.length > 0) {
         lines.push('', sectionHeader('Exit transitions'));
         for (const tr of input.transitions) {
-            lines.push(transitionLine(tr));
+            lines.push(transitionLine(tr, explanations?.get(tr.transition.name)));
         }
     }
     return lines;
@@ -39,14 +42,14 @@ function currentStageLines(input) {
 function failedEffectDetail(effect) {
     const ran = effect.durationMs !== undefined ? ` (after ${effect.durationMs}ms)` : '';
     return {
-        headline: `a failed effect is blocking activity '${effect.origin.name}'`,
+        headline: `a failed effect from action '${effect.origin.name}' is blocking its activity`,
         why: [
             styleText('red', `${logSymbols.error} failed effect: ${effect.name}`),
-            `  queued by activity '${effect.origin.name}', failed ${formatTimestamp(effect.ranAt)}${ran}`,
+            `  queued by action '${effect.origin.name}', failed ${formatTimestamp(effect.ranAt)}${ran}`,
             ...(effect.error !== undefined ? [`  error: ${effect.error.message}`] : []),
             '',
-            `Activity '${effect.origin.name}' is waiting on this effect. It failed against an`,
-            `external system, so the activity never completes and the stage can't advance.`,
+            `The activity that fired '${effect.origin.name}' is waiting on this effect. It failed`,
+            `against an external system, so the activity never resolves and the stage can't advance.`,
         ],
     };
 }
@@ -71,12 +74,22 @@ function failedActivityDetail(activity) {
 }
 function waitingHeadline(w) {
     const who = w.assignees.length > 0 ? ` on ${w.assignees.map(formatAssignee).join(', ')}` : '';
+    if (w.actions.length === 0) {
+        return `waiting${who} on automation — a trigger fires on its own when its condition holds`;
+    }
     return `waiting${who} for action: ${w.actions.join(' or ')}`;
 }
 function waitingLines(w) {
     const who = w.assignees.length > 0
         ? `assigned to ${w.assignees.map(formatAssignee).join(', ')}`
         : 'unassigned — anyone with permission can act';
+    if (w.actions.length === 0) {
+        return [
+            `${logSymbols.info} activity '${w.activity}' is active (${who}),`,
+            `waiting on automation: its cascade-fired action(s) fire on their own when their`,
+            `trigger conditions hold — nothing for a caller to fire.`,
+        ];
+    }
     return [
         `${logSymbols.info} activity '${w.activity}' is active (${who}),`,
         `waiting for action: ${w.actions.join(' or ')}. This is the normal in-flight`,
@@ -100,36 +113,25 @@ function blockedLines(b) {
 }
 function noTransitionDetail() {
     return {
-        headline: `no exit transition's filter is satisfied`,
+        headline: `no exit transition's trigger is satisfied`,
         why: [
-            `${logSymbols.info} every activity is resolved, but no exit transition's filter is true.`,
-            `Likely a routing state value a filter reads never got written.`,
+            `${logSymbols.info} every activity is resolved, but no exit transition's \`when\` is true.`,
+            `Likely a routing state value a trigger reads never got written.`,
         ],
     };
 }
-/** An unevaluable exit filter is a *recoverable* hold, not a dead end: it
- *  clears itself once the operand becomes readable, and no engine verb
- *  unsticks it (so the engine emits no remediation). The "what to do" —
- *  make the operand readable — lives here in the why, since there is no
- *  runnable fix to render. */
 function transitionUnevaluableDetail(transitions) {
     return {
-        headline: `an exit transition's filter could not be evaluated`,
+        headline: `an exit transition's trigger could not be evaluated`,
         why: [
             `${logSymbols.info} every activity is resolved, but ${transitions.join(', ')} reads an operand`,
             `that is missing or unreadable (GROQ null), so routing is held rather than`,
-            `falling through. Make the data the filter reads readable — publish the`,
+            `falling through. Make the data the trigger reads readable — publish the`,
             `subject (or fill the field) — and the instance advances on its own; no`,
             `set-stage needed.`,
         ],
     };
 }
-/** Render the engine's structured remediations as the "suggested fix" block.
- *  Verbs render under their engine names — the same vocabulary `--json`
- *  emits, so scripts and humans read one language. Only runnable ones reach
- *  here: {@link renderDiagnosis} filters on the engine's `available` flag,
- *  so verbs that aren't callable engine operations yet never render as a
- *  fix (the full set, planned verbs included, still rides `--json`). */
 function remediationLines(remediations) {
     return remediations.map((r) => `  • ${r.verb} — ${r.rationale}`);
 }
@@ -147,6 +149,11 @@ function causeDetail(cause) {
             return transitionUnevaluableDetail(cause.transitions);
     }
 }
+function liveChildrenTail(diagnosis) {
+    if (diagnosis.liveChildren === undefined)
+        return '';
+    return ` ${styleText('yellow', `${diagnosis.liveChildren} spawned child workflow(s) still running.`)}`;
+}
 function statusLine(diagnosis) {
     switch (diagnosis.state) {
         case 'progressing':
@@ -156,31 +163,37 @@ function statusLine(diagnosis) {
         case 'blocked':
             return `${logSymbols.info} ${styleText('cyan', 'blocked')} — ${blockedHeadline(diagnosis)}`;
         case 'completed':
-            return `${logSymbols.success} ${styleText('green', 'completed')} at ${formatTimestamp(diagnosis.at)}.`;
+            return `${logSymbols.success} ${styleText('green', 'completed')} at ${formatTimestamp(diagnosis.at)}.${liveChildrenTail(diagnosis)}`;
         case 'aborted': {
             const tail = diagnosis.reason !== undefined ? ` — ${diagnosis.reason}` : '';
-            return `${logSymbols.info} ${styleText('dim', 'aborted')} at ${formatTimestamp(diagnosis.at)}${tail}.`;
+            return `${logSymbols.info} ${styleText('dim', 'aborted')} at ${formatTimestamp(diagnosis.at)}${tail}.${liveChildrenTail(diagnosis)}`;
         }
         case 'stuck':
             return `${logSymbols.warning} ${styleText('yellow', 'STUCK')} — ${causeDetail(diagnosis.cause).headline}`;
     }
 }
-/**
- * The diagnosis body: the verdict line, the current stage's activities +
- * transitions as evidence (for any in-flight state), and the cause block with
- * the engine's suggested fix when stuck. Pure so every verdict permutation is
- * assertable without driving a live evaluation. Takes the engine's
- * {@link SuggestedRemediation}s rather than re-deriving them, so the rendered
- * fix block and the `--json` output stay one computation.
- */
-export function renderDiagnosis({ diagnosis, input, remediations, }) {
+export function rawTransitionProjection(evaluation) {
+    return evaluation.currentStage.transitions.map((t) => ({
+        name: t.transition.name,
+        to: t.transition.to,
+        whenSatisfied: t.whenSatisfied,
+        unevaluable: t.unevaluable,
+        blockedBy: t.insight.blockedBy.map((atom) => ({
+            groq: atom.atom.groq,
+            negated: atom.atom.negated,
+            pivotal: atom.pivotal,
+            ...(atom.requirement !== undefined ? { requirement: atom.requirement } : {}),
+        })),
+    }));
+}
+export function renderDiagnosis({ diagnosis, input, remediations, explanations, }) {
     const lines = [statusLine(diagnosis)];
     const inFlight = diagnosis.state === 'progressing' ||
         diagnosis.state === 'waiting' ||
         diagnosis.state === 'blocked' ||
         diagnosis.state === 'stuck';
     if (inFlight) {
-        lines.push('', ...currentStageLines(input));
+        lines.push('', ...currentStageLines(input, explanations));
     }
     if (diagnosis.state === 'waiting') {
         lines.push('', ...waitingLines(diagnosis));
@@ -192,16 +205,13 @@ export function renderDiagnosis({ diagnosis, input, remediations, }) {
         const detail = causeDetail(diagnosis.cause);
         const runnable = remediations.filter((r) => r.available);
         lines.push('', sectionHeader("Why it's stuck"), ...detail.why);
-        // A recoverable hold (e.g. an unevaluable transition filter) has no
-        // runnable remediation — its "what to do" is in the why above, so skip
-        // the empty fix header rather than dangle it.
         if (runnable.length > 0) {
             lines.push('', sectionHeader('Suggested fix'), ...remediationLines(runnable));
         }
     }
     return lines;
 }
-export default class Diagnose extends Command {
+export default class Diagnose extends WorkflowCommand {
     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',
@@ -221,18 +231,10 @@ export default class Diagnose extends Command {
         const { evaluation, diagnosis, remediations } = await workflow
             .diagnose({
             client,
-            tag: scope.tag,
-            workflowResource: scope.workflowResource,
+            ...baseEngineArgs(scope),
             instanceId: args.instanceId,
-            // Token-auth CLI can't hit /users/me; pin the same system actor the
-            // write verbs use. Transition filters and activity status are actor-
-            // independent. A requirement that reads $actor/$assigned/$can is the
-            // exception — it's evaluated against this system actor, so a `blocked`
-            // verdict on such a requirement reflects the engine's view, not a
-            // specific assignee's.
-            access: { actor: { kind: 'system', id: 'workflow-cli' } },
         })
-            .catch((error) => fail('diagnose failed:', errorMessage(error)));
+            .catch((error) => fail('diagnose failed:', failureDetail(error)));
         const input = diagnoseInputFromEvaluation(evaluation);
         if (flags.json) {
             this.log(JSON.stringify({
@@ -240,12 +242,14 @@ export default class Diagnose extends Command {
                 stage: evaluation.instance.currentStage,
                 diagnosis,
                 remediations,
+                transitions: rawTransitionProjection(evaluation),
             }, null, 2));
             return;
         }
         this.log(instanceHeader(evaluation.instance));
         this.log('');
-        for (const line of renderDiagnosis({ diagnosis, input, remediations })) {
+        const explanations = new Map(unsatisfiedTransitionSummaries(evaluation).map((entry) => [entry.transition, entry.summary]));
+        for (const line of renderDiagnosis({ diagnosis, input, remediations, explanations })) {
             this.log(line);
         }
     }

package/dist/commands/fire-action.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
 import { type AvailableAction } from '@sanity/workflow-engine';
+import { WorkflowCommand } from '../lib/base-command.ts';
 import { type WriteOutcome, type WriteReport } from '../lib/ops-report.ts';
 /**
  * The list-mode body: every action on the current stage's activities, marked
@@ -29,7 +29,7 @@ export declare function fireActionReport({ result, activity, action, }: {
     activity: string;
     action: string;
 }): WriteReport;
-export default class FireAction extends Command {
+export default class FireAction extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static args: {
@@ -37,8 +37,6 @@ export default class FireAction extends Command {
     };
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        as: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'as-role': import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         activity: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         action: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         param: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/fire-action.js

@@ -1,37 +1,38 @@
 import { styleText } from 'node:util';
-import { Args, Command, Flags } from '@oclif/core';
-import { deniedGuardLabels, workflow, } from '@sanity/workflow-engine';
+import { Args, Flags } from '@oclif/core';
+import { actionRendering, actionDisabledDetail, deniedGuardLabels, workflow, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import ora from 'ora';
+import { WorkflowCommand } from "../lib/base-command.js";
 import { resolveInstanceContext } from "../lib/context.js";
-import { errorMessage, fail, failOnThrow } from "../lib/fail.js";
-import { actorFlags, jsonFlags, tagFlags } from "../lib/flags.js";
-import { baseEngineArgs, resolveActor } from "../lib/operation-args.js";
-import { emitWriteReport, opsAppliedLines, } from "../lib/ops-report.js";
+import { fail, failOnThrow, failureDetail } from "../lib/fail.js";
+import { jsonFlags, tagFlags } from "../lib/flags.js";
+import { baseEngineArgs } from "../lib/operation-args.js";
+import { cascadeTail, opsAppliedLines, runWriteVerb, } from "../lib/ops-report.js";
 import { parseParams } from "../lib/params.js";
 import { instanceHeader } from "./show.js";
 function reasonText(reason) {
-    switch (reason.kind) {
-        case 'filter-failed':
-            return `action filter not satisfied${reason.detail ? ` (${reason.detail})` : ''}`;
-        case 'activity-not-active':
-            return `activity is ${reason.status}`;
-        case 'stage-terminal':
-            return `stage '${reason.stage}' is terminal`;
-        case 'mutation-guard-denied':
-            return `blocked by mutation guard(s) ${deniedGuardLabels(reason.denied).join(', ')}`;
-        case 'instance-completed':
-            return `instance completed at ${reason.completedAt}`;
-        case 'requirements-unmet':
-            return `unmet requirement(s): ${reason.unmetRequirements.join(', ')}`;
+    if (reason.kind === 'mutation-guard-denied') {
+        return `blocked by mutation guard(s) ${deniedGuardLabels(reason.denied).join(', ')}`;
     }
+    return actionDisabledDetail(reason);
 }
 function paramLabel(p) {
     return `${p.name}${p.required === true ? '' : '?'}:${p.type}`;
 }
 function actionLines(a) {
-    const mark = a.allowed ? logSymbols.success : logSymbols.error;
     const title = a.title !== undefined ? styleText('dim', `  (${a.title})`) : '';
+    const rendering = actionRendering(a);
+    if (rendering === 'absent')
+        return [];
+    if (rendering === 'automation') {
+        return [
+            `  ${styleText('cyan', '⚡')} ${a.activity} → ${a.action}${title} ${styleText('dim', '[automation]')}`,
+            ...(a.disabledReason?.kind === 'cascade-fired'
+                ? [styleText('dim', `      ${actionDisabledDetail(a.disabledReason)}`)]
+                : []),
+        ];
+    }
+    const mark = a.allowed ? logSymbols.success : logSymbols.error;
     const lines = [
         `  ${mark} ${a.activity} → ${a.action}${title} ${styleText('dim', `[activity ${a.activityStatus}]`)}`,
     ];
@@ -43,12 +44,6 @@ function actionLines(a) {
     }
     return lines;
 }
-/**
- * The list-mode body: every action on the current stage's activities, marked
- * fireable or not (with the disabling reason), plus a hint showing the
- * flags to fire one. Pure so the populated/empty permutations assert
- * without a live evaluation.
- */
 export function renderAvailableActions({ actions, stage, instanceId, }) {
     if (actions.length === 0) {
         return [`No actions on the activities of the current stage ('${stage}').`];
@@ -60,8 +55,6 @@ export function renderAvailableActions({ actions, stage, instanceId, }) {
     lines.push('', styleText('dim', 'Fire one with:'), styleText('dim', `  fire-action ${instanceId} --activity <activity> --action <action>`));
     return lines;
 }
-/** The `--json` payload for a fired action — the structured counterpart of
- *  {@link fireActionReport}. Pure so its shape is asserted directly. */
 export function fireResultJson(result, ids) {
     return {
         instanceId: ids.instanceId,
@@ -73,11 +66,6 @@ export function fireResultJson(result, ids) {
         ...(result.ranOps !== undefined ? { ranOps: result.ranOps } : {}),
     };
 }
-/**
- * Turn a `fireAction` result into the spinner message + ops block. Pure so
- * the fired / no-op / cascaded / ops permutations assert without a live
- * fire.
- */
 export function fireActionReport({ result, activity, action, }) {
     const stage = styleText('bold', result.instance.currentStage);
     if (!result.changed) {
@@ -87,19 +75,17 @@ export function fireActionReport({ result, activity, action, }) {
             opsLines: [],
         };
     }
-    const tail = result.cascaded > 0 ? `, then cascaded ${result.cascaded} auto-transition(s)` : '';
     return {
         changed: true,
-        message: `Fired ${styleText('bold', action)} on ${styleText('bold', activity)} — now at ${stage}${tail}`,
+        message: `Fired ${styleText('bold', action)} on ${styleText('bold', activity)} — now at ${stage}${cascadeTail(result.cascaded)}`,
         opsLines: opsAppliedLines(result.ranOps),
     };
 }
-export default class FireAction extends Command {
-    static description = "Fire an action on an instance — act on a user's behalf to unstick a waiting activity. Omit --action to list what can be fired.";
+export default class FireAction extends WorkflowCommand {
+    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 approve --action approve --as user.xyz --as-role editor',
         '<%= config.bin %> fire-action wf-instance.abc123 --activity publish --action publish --param note=shipping',
     ];
     static args = {
@@ -118,19 +104,16 @@ export default class FireAction extends Command {
             multiple: true,
             default: [],
         }),
-        ...actorFlags,
         ...jsonFlags,
     };
     async run() {
         const { args, flags } = await this.parse(FireAction);
         const { client, scope } = await resolveInstanceContext(flags, args.instanceId);
-        const actor = failOnThrow('fire-action usage error:', () => resolveActor(flags.as, flags['as-role']));
         if (flags.action === undefined) {
             await this.listActions({
                 client,
                 scope,
                 instanceId: args.instanceId,
-                actor,
                 json: flags.json,
             });
             return;
@@ -142,21 +125,20 @@ export default class FireAction extends Command {
             client,
             scope,
             instanceId: args.instanceId,
-            actor,
             activity: flags.activity,
             action: flags.action,
             params: flags.param,
             json: flags.json,
         });
     }
-    async listActions({ client, scope, instanceId, actor, json, }) {
+    async listActions({ client, scope, instanceId, json, }) {
         const { evaluation, actions } = await workflow
             .availableActions({
             client,
-            ...baseEngineArgs(scope, actor),
+            ...baseEngineArgs(scope),
             instanceId,
         })
-            .catch((error) => fail('fire-action failed:', errorMessage(error)));
+            .catch((error) => fail('fire-action failed:', failureDetail(error)));
         const stage = evaluation.instance.currentStage;
         if (json) {
             this.log(JSON.stringify({ instanceId, stage, actions }, null, 2));
@@ -169,11 +151,11 @@ export default class FireAction extends Command {
         }
     }
     async fireOne(opts) {
-        const { client, scope, instanceId, actor, activity, action, json } = opts;
+        const { client, scope, instanceId, activity, action, json } = opts;
         const params = failOnThrow('Invalid --param:', () => parseParams(opts.params));
         const fireArgs = {
             client,
-            ...baseEngineArgs(scope, actor),
+            ...baseEngineArgs(scope),
             instanceId,
             activity,
             action,
@@ -182,22 +164,17 @@ export default class FireAction extends Command {
         if (json) {
             const result = await workflow
                 .fireAction(fireArgs)
-                .catch((error) => fail('fire-action error:', errorMessage(error)));
+                .catch((error) => fail('fire-action error:', failureDetail(error)));
             this.log(JSON.stringify(fireResultJson(result, { instanceId, activity, action }), null, 2));
             return;
         }
-        const spinner = ora(`Firing ${action} on ${activity}…`).start();
-        try {
-            const result = await workflow.fireAction(fireArgs);
-            emitWriteReport({
-                spinner,
-                report: fireActionReport({ result, activity, action }),
-                log: (line) => this.log(line),
-            });
-        }
-        catch (error) {
-            spinner.fail('Action rejected');
-            fail('fire-action error:', errorMessage(error));
-        }
+        await runWriteVerb({
+            startLabel: `Firing ${action} on ${activity}…`,
+            failLabel: 'Action rejected',
+            failHeadline: 'fire-action error:',
+            run: () => workflow.fireAction(fireArgs),
+            report: (result) => fireActionReport({ result, activity, action }),
+            log: (line) => this.log(line),
+        });
     }
 }

package/dist/commands/list.d.ts

@@ -1,18 +1,19 @@
-import { Command } from '@oclif/core';
+import { type TerminalState } from '@sanity/workflow-engine';
+import { WorkflowCommand } from '../lib/base-command.ts';
 interface InstanceRow {
     _id: string;
     definition: string;
     tag: string;
     currentStage: string;
-    completedAt?: string;
-    abortedAt?: string;
+    completedAt?: string | null;
+    abortedAt?: string | null;
     lastChangedAt: string;
 }
-type InstanceStatus = 'aborted' | 'completed' | 'in-flight';
 interface ListFlags {
-    'in-flight': boolean;
+    'include-completed': boolean;
     failed: boolean;
     definition?: string | undefined;
+    document?: string | undefined;
     tag?: string | undefined;
     limit: number;
 }
@@ -20,28 +21,35 @@ interface ListFlags {
  * Build the GROQ query + params for `list` from its flags. Pure so the
  * filter combinations can be asserted without a live dataset. `--tag` is an
  * optional filter: omit it and the listing spans every partition.
+ *
+ * With `--document` the lake filter is the engine's prefilter arm — a
+ * deliberate superset narrowed to the exact watch-set in JS
+ * ({@link instanceWatchesDocument}) — so the rows come back as full
+ * documents (the narrowing reads fields/stages/ancestors) and UNCAPPED: a
+ * capped superset could silently hide matches. The display limit applies
+ * after narrowing.
  */
 export declare function buildListQuery(flags: ListFlags): {
     groq: string;
     params: Record<string, unknown>;
 };
-/** Map a queried instance to its display row (derives the status column).
- *  Pure — status is the semantic value; the table colors it at render. */
+/** Map a queried instance to its display row (derives the status column). */
 export declare function instanceRow(r: InstanceRow): {
     _id: string;
     definition: string;
     tag: string;
     currentStage: string;
-    status: InstanceStatus;
+    status: TerminalState;
     lastChangedAt: string;
 };
-export default class List extends Command {
+export default class List extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        'in-flight': 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>;
+        document: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };