@sanity/workflow-cli 0.9.0 → 0.10.0

package/dist/commands/fire-action.js

@@ -1,30 +1,20 @@
 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 { 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}`;
@@ -43,12 +33,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 +44,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 +55,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 +64,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 +93,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 +114,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 +140,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 +153,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,14 +1,14 @@
-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;
     failed: boolean;
@@ -25,17 +25,16 @@ 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: {

package/dist/commands/list.js

@@ -1,23 +1,17 @@
-import { styleText } from 'node:util';
-import { Command, Flags } from '@oclif/core';
-import { WORKFLOW_INSTANCE_TYPE, tagScopeFilter } from '@sanity/workflow-engine';
-import { Table } from 'console-table-printer';
+import { Flags } from '@oclif/core';
+import { WORKFLOW_INSTANCE_TYPE, tagScopeFilter, terminalState, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import { resolveReadContext } from "../lib/context.js";
+import { WorkflowCommand } from "../lib/base-command.js";
+import { resolveReadTargets } from "../lib/context.js";
 import { tagFlags } from "../lib/flags.js";
-import { formatAge } from "../lib/ui.js";
-/**
- * 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.
- */
+import { runReadAcrossTargets } from "../lib/read-fanout.js";
+import { clipToLimit, formatAge, formatTable } from "../lib/ui.js";
 export function buildListQuery(flags) {
     const filters = [`_type == "${WORKFLOW_INSTANCE_TYPE}"`];
     if (flags['in-flight'])
         filters.push('!defined(completedAt)');
     if (flags.definition)
         filters.push('definition == $definition');
-    // Cheap approximation of --failed: any activity in any stage with status "failed".
     if (flags.failed)
         filters.push('count(stages[].activities[status == "failed"]) > 0');
     if (flags.tag)
@@ -31,39 +25,27 @@ export function buildListQuery(flags) {
       abortedAt,
       lastChangedAt
     }`;
-    const params = { limit: flags.limit };
+    const params = { limit: flags.limit + 1 };
     if (flags.definition)
         params['definition'] = flags.definition;
     if (flags.tag)
         params['tag'] = flags.tag;
     return { groq, params };
 }
-/** Aborted instances also carry `completedAt`, so check `abortedAt` first. */
-function deriveStatus(r) {
-    if (r.abortedAt)
-        return 'aborted';
-    if (r.completedAt)
-        return 'completed';
-    return 'in-flight';
-}
-/** Map a queried instance to its display row (derives the status column).
- *  Pure — status is the semantic value; the table colors it at render. */
 export function instanceRow(r) {
     return {
         _id: r._id,
         definition: r.definition,
         tag: r.tag,
         currentStage: r.currentStage,
-        status: deriveStatus(r),
+        status: terminalState({
+            ...(r.completedAt != null ? { completedAt: r.completedAt } : {}),
+            ...(r.abortedAt != null ? { abortedAt: r.abortedAt } : {}),
+        }),
         lastChangedAt: r.lastChangedAt,
     };
 }
-const STATUS_COLOR = {
-    completed: 'green',
-    aborted: 'dim',
-    'in-flight': 'cyan',
-};
-export default class List extends Command {
+export default class List extends WorkflowCommand {
     static description = 'List workflow instances in the configured dataset.';
     static examples = [
         '<%= config.bin %> list',
@@ -91,34 +73,39 @@ export default class List extends Command {
     };
     async run() {
         const { flags } = await this.parse(List);
-        const { client } = await resolveReadContext(flags);
+        const targets = await resolveReadTargets(flags);
         const { groq, params } = buildListQuery(flags);
-        const rows = await client.fetch(groq, params);
-        if (rows.length === 0) {
-            this.log(`${logSymbols.info} no instances match`);
-            return;
-        }
-        const table = new Table({
-            columns: [
-                { name: '_id', title: 'Instance', alignment: 'left' },
-                { name: 'definition', title: 'Workflow', alignment: 'left' },
-                { name: 'tag', title: 'Tag', alignment: 'left' },
-                { name: 'currentStage', title: 'Stage', alignment: 'left' },
-                { name: 'status', title: 'Status', alignment: 'left' },
-                { name: 'updated', title: 'Updated', alignment: 'left' },
-            ],
+        const failures = await runReadAcrossTargets({
+            targets,
+            log: (line) => this.log(line),
+            run: async ({ client }) => {
+                const fetched = await client.fetch(groq, params, { tag: 'list' });
+                if (fetched.length === 0) {
+                    this.log(`${logSymbols.info} no instances match`);
+                    return;
+                }
+                const { rows, note } = clipToLimit(fetched, flags.limit);
+                const lines = formatTable(['instance', 'workflow', 'tag', 'stage', 'status', 'updated'], rows.map((r) => {
+                    const row = instanceRow(r);
+                    return [
+                        row._id,
+                        row.definition,
+                        row.tag,
+                        row.currentStage,
+                        row.status,
+                        formatAge(row.lastChangedAt),
+                    ];
+                }));
+                for (const line of lines) {
+                    this.log(line);
+                }
+                if (note) {
+                    this.log(note);
+                }
+            },
         });
-        for (const r of rows) {
-            const row = instanceRow(r);
-            table.addRow({
-                _id: row._id,
-                definition: row.definition,
-                tag: row.tag,
-                currentStage: row.currentStage,
-                status: styleText(STATUS_COLOR[row.status], row.status),
-                updated: formatAge(row.lastChangedAt),
-            });
+        if (failures.length > 0) {
+            this.exit(1);
         }
-        table.printTable();
     }
 }

package/dist/commands/reset-activity.js

@@ -1,7 +1,6 @@
 import { Args } from '@oclif/core';
 import { StubCommand } from "../lib/stub.js";
 export default class ResetActivity extends StubCommand {
-    // Stubbed, so kept off the help + published surface until it's wired.
     static hidden = true;
     static description = 'Reset a failed activity on an in-flight instance — back to pending (re-run) or to skipped (bypass).';
     static args = {

package/dist/commands/set-stage.d.ts

@@ -1,8 +1,8 @@
-import { Command } from '@oclif/core';
 import { type SetStageArgs, type WorkflowInstance } from '@sanity/workflow-engine';
+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 Command {
+export default class SetStage extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/set-stage.js

@@ -1,13 +1,12 @@
 import { styleText } from 'node:util';
-import { Args, Command, Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { workflow } from '@sanity/workflow-engine';
-import ora from 'ora';
+import { WorkflowCommand } from "../lib/base-command.js";
 import { resolveInstanceContext } from "../lib/context.js";
-import { errorMessage, fail } from "../lib/fail.js";
 import { tagFlags } from "../lib/flags.js";
 import { buildOperationArgs } from "../lib/operation-args.js";
-import { emitWriteReport, opsAppliedLines, } from "../lib/ops-report.js";
-export default class SetStage extends Command {
+import { cascadeTail, opsAppliedLines, runWriteVerb, } from "../lib/ops-report.js";
+export default class SetStage extends WorkflowCommand {
     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',
@@ -32,9 +31,11 @@ export default class SetStage extends Command {
     async run() {
         const { args, flags } = await this.parse(SetStage);
         const { client, scope } = await resolveInstanceContext(flags, args.instanceId);
-        const spinner = ora(`Setting ${args.instanceId} → ${flags.to}…`).start();
-        try {
-            const result = await workflow.setStage({
+        await runWriteVerb({
+            startLabel: `Setting ${args.instanceId} → ${flags.to}…`,
+            failLabel: 'Stage move rejected',
+            failHeadline: 'set-stage error:',
+            run: () => workflow.setStage({
                 client,
                 ...buildSetStageArgs({
                     scope,
@@ -42,44 +43,27 @@ export default class SetStage extends Command {
                     targetStage: flags.to,
                     reason: flags.reason,
                 }),
-            });
-            emitWriteReport({
-                spinner,
-                report: setStageReport(result, flags.to),
-                log: (line) => this.log(line),
-            });
-        }
-        catch (error) {
-            spinner.fail('Stage move rejected');
-            fail('set-stage error:', errorMessage(error));
-        }
+            }),
+            report: (result) => setStageReport(result, flags.to),
+            log: (line) => this.log(line),
+        });
     }
 }
-/** The shared operation args ({@link buildOperationArgs}) plus the
- *  setStage-specific target. */
 export function buildSetStageArgs({ scope, instanceId, targetStage, reason, }) {
     return { ...buildOperationArgs({ scope, instanceId, reason }), targetStage };
 }
-/**
- * Turn a `setStage` result into the spinner message + ops block. Pure so
- * the changed / terminal / already-at-target / cascaded / ops permutations
- * can be asserted without driving a real move.
- */
 export function setStageReport(result, to) {
     const stage = styleText('bold', result.instance.currentStage);
     if (!result.changed) {
-        // The engine no-ops in two distinct cases: a terminal instance never
-        // moves again, and a same-stage move has nothing to do.
         const { completedAt } = result.instance;
         const message = completedAt !== undefined
             ? `setStage changed nothing — instance is terminal (at ${stage} since ${completedAt})`
             : `setStage changed nothing — instance is already at ${stage}`;
         return { changed: false, message, opsLines: [] };
     }
-    const tail = result.cascaded > 0 ? `, then cascaded ${result.cascaded} auto-transition(s)` : '';
     return {
         changed: true,
-        message: `Now at ${stage} (was → ${to}${tail})`,
+        message: `Now at ${stage} (was → ${to}${cascadeTail(result.cascaded)})`,
         opsLines: opsAppliedLines(result.ranOps),
     };
 }

package/dist/commands/show.d.ts

@@ -1,6 +1,6 @@
-import { Command } from '@oclif/core';
 import { type WorkflowInstance } from '@sanity/workflow-engine';
-export default class Show extends Command {
+import { WorkflowCommand } from '../lib/base-command.ts';
+export default class Show extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/show.js

@@ -1,11 +1,12 @@
 import { styleText } from 'node:util';
-import { Args, Command, Flags } from '@oclif/core';
-import { abortReason } from '@sanity/workflow-engine';
+import { Args, Flags } from '@oclif/core';
+import { abortReason, displayTitle, terminalState, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import { resolveReadContext } from "../lib/context.js";
+import { WorkflowCommand } from "../lib/base-command.js";
+import { findInstance, resolveReadTargets } from "../lib/context.js";
 import { tagFlags } from "../lib/flags.js";
 import { formatKeyValue, formatTimestamp, sectionHeader, activityIcon } from "../lib/ui.js";
-export default class Show extends Command {
+export default class Show extends WorkflowCommand {
     static description = 'Show the state, activities, and effects of a workflow instance.';
     static examples = [
         '<%= config.bin %> show wf-instance.abc123',
@@ -28,11 +29,12 @@ export default class Show extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(Show);
-        const { client } = await resolveReadContext(flags);
-        const instance = await client.getDocument(args.instanceId);
-        if (!instance) {
+        const targets = await resolveReadTargets(flags);
+        const hit = await findInstance({ targets, instanceId: args.instanceId, requestTag: 'show' });
+        if (!hit) {
             this.error(`${logSymbols.error} no instance with id "${args.instanceId}"`, { exit: 1 });
         }
+        const { instance } = hit;
         this.log(instanceHeader(instance));
         this.log('');
         for (const line of describeInstance(instance, {
@@ -42,19 +44,14 @@ export default class Show extends Command {
         }
     }
 }
-const HEADER_PAD = 9; // "Completed" — the longest label in the block
-/** The summary block at the top of `show` (and reused by `diagnose` /
- *  `fire-action`): a bold workflow + id title, then aligned detail rows. */
+const HEADER_PAD = 9;
 export function instanceHeader(instance) {
     const title = `${styleText('bold', `${instance.definition} v${instance.pinnedVersion}`)}  ${styleText('cyan', instance._id)}`;
     const rows = [
         formatKeyValue({ key: 'Stage', value: instance.currentStage, padTo: HEADER_PAD }),
         formatKeyValue({ key: 'Started', value: formatTimestamp(instance.startedAt), padTo: HEADER_PAD }),
     ];
-    // Aborted instances also carry a completedAt stamped at the abort, so the
-    // abort line stands in for completion — showing a green "Completed" too would
-    // misread as success.
-    if (instance.abortedAt) {
+    if (terminalState(instance) === 'aborted' && instance.abortedAt !== undefined) {
         const reason = abortReason(instance);
         const tail = reason ? ` — ${reason}` : '';
         const value = styleText('yellow', `${formatTimestamp(instance.abortedAt)}${tail}`);
@@ -69,11 +66,6 @@ export function instanceHeader(instance) {
     rows.push(formatKeyValue({ key: 'Tag', value: instance.tag, padTo: HEADER_PAD }));
     return [title, ...rows].join('\n');
 }
-/**
- * The per-instance body lines: every stage with its activities, any pending
- * effects, and (optionally) the history log. Pure so it can be asserted
- * without driving the oclif command.
- */
 export function describeInstance(instance, options) {
     const lines = [sectionHeader('Stages')];
     for (const stage of instance.stages) {
@@ -81,10 +73,6 @@ export function describeInstance(instance, options) {
             ? styleText('dim', ` (exited ${formatTimestamp(stage.exitedAt)})`)
             : styleText('cyan', ' (current)');
         lines.push(`  • ${stage.name}${marker}`);
-        // A persisted stage may carry no activities array — an activity-less stage,
-        // or an older-shape document — so treat an absent list as none rather than
-        // crash. This renders whatever is in the lake, not only freshly-stamped
-        // instances; it does not reconstruct activity state from history.
         for (const activity of stage.activities ?? []) {
             lines.push(`      ${activityIcon[activity.status]} ${activity.name}  ${styleText('dim', `[${activity.status}]`)}`);
         }
@@ -98,7 +86,7 @@ export function describeInstance(instance, options) {
     if (options.includeHistory) {
         lines.push('', sectionHeader('History'));
         for (const entry of instance.history) {
-            lines.push(`  ${styleText('dim', `[${formatTimestamp(entry.at)}]`)} ${entry._type}`);
+            lines.push(`  ${styleText('dim', `[${formatTimestamp(entry.at)}]`)} ${displayTitle(entry._type)}`);
         }
     }
     return lines;

package/dist/commands/start.d.ts

@@ -1,7 +1,7 @@
-import { Command } from '@oclif/core';
-import { type Actor, type FieldEntry, type InitialFieldValue, type StartInstanceArgs, type WorkflowInstance, type WorkflowLifecycle } from '@sanity/workflow-engine';
+import { type FieldEntry, type InitialFieldValue, type StartInstanceArgs, type WorkflowInstance, type WorkflowLifecycle } from '@sanity/workflow-engine';
+import { WorkflowCommand } from '../lib/base-command.ts';
 import { type EngineScope } from '../lib/operation-args.ts';
-export default class Start extends Command {
+export default class Start extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static args: {
@@ -9,8 +9,6 @@ export default class Start 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>;
         version: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         field: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -43,12 +41,11 @@ export declare function buildInitialFields({ declared, values, }: {
  * fields. Optionals spread conditionally because the engine's optional args
  * reject an explicit `undefined` under `exactOptionalPropertyTypes`.
  */
-export declare function buildStartArgs({ scope, name, version, initialFields, actor, }: {
+export declare function buildStartArgs({ scope, name, version, initialFields, }: {
     scope: EngineScope;
     name: string;
     version: number | undefined;
     initialFields: InitialFieldValue[];
-    actor: Actor;
 }): StartInstanceArgs & EngineScope;
 /** The success spinner message. Pure so the in-flight / immediately-terminal
  *  permutations can be asserted without driving a real start. */