@sanity/workflow-cli 0.7.1 → 0.8.1

package/README.md

@@ -4,7 +4,7 @@ Command-line tool for deploying, inspecting, and administering Sanity workflow
 definitions and instances.
 
 > [!WARNING]
-> Early access, restricted. `retry-task` and `set-stage` are still stubs —
+> Early access, restricted. `retry-activity` and `set-stage` are still stubs —
 > they print their parsed input and exit non-zero. The "wired" commands below
 > talk to a real Sanity dataset using `SANITY_*` env vars.
 
@@ -75,25 +75,25 @@ built or standalone CLI instead resolves the package's compiled `dist`.
 
 ## Command status
 
-| Command                                    | Status                                                                                    |
-| ------------------------------------------ | ----------------------------------------------------------------------------------------- |
-| `deploy`                                   | wired — calls `workflow.deployDefinitions` over the `WORKFLOW_DEFS` module                |
-| `deploy --check`                           | wired — runs `validateDefinition` over the local batch + a duplicate-id check             |
-| `deploy --dry-run`                         | wired — fetches existing docs and renders a coloured JSON diff per change                 |
-| `deploy --only <id>`                       | wired — filters deploy/check/dry-run to one `definition`                                  |
-| `list`                                     | wired — `client.fetch` over `workflow.instance` documents                                 |
-| `show <instance-id>`                       | wired — `client.getDocument`                                                              |
-| `diagnose <instance-id>`                   | wired — one `workflow.evaluate` call, 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, lifts guards) |
-| `retry-task <instance-id> <task-id>`       | stub                                                                                      |
-| `move-stage <instance-id> --to <stage-id>` | wired — calls `workflow.setStage` (runs guards + onEnter effects)                         |
-| `fire-action <instance-id>`                | wired — `workflow.evaluate` lists actions; `workflow.fireAction` fires one                |
-| `set-stage <instance-id> --to <stage-id>`  | stub (engine has no guard-bypass path yet)                                                |
-| `definition list`                          | wired — `client.fetch` over `workflow.definition` documents                               |
-| `definition show <id>`                     | wired — `client.fetch`, latest version unless `--version`                                 |
-| `definition diff <id>`                     | 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`)  |
+| Command                                      | Status                                                                                    |
+| -------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `deploy`                                     | wired — calls `workflow.deployDefinitions` over the `WORKFLOW_DEFS` module                |
+| `deploy --check`                             | wired — runs `validateDefinition` over the local batch + a duplicate-id check             |
+| `deploy --dry-run`                           | wired — fetches existing docs and renders a coloured JSON diff per change                 |
+| `deploy --only <id>`                         | wired — filters deploy/check/dry-run to one `definition`                                  |
+| `list`                                       | wired — `client.fetch` over `workflow.instance` documents                                 |
+| `show <instance-id>`                         | wired — `client.getDocument`                                                              |
+| `diagnose <instance-id>`                     | wired — one `workflow.evaluate` call, 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, lifts guards) |
+| `retry-activity <instance-id> <activity-id>` | stub                                                                                      |
+| `move-stage <instance-id> --to <stage-id>`   | wired — calls `workflow.setStage` (runs guards + onEnter effects)                         |
+| `fire-action <instance-id>`                  | wired — `workflow.evaluate` lists actions; `workflow.fireAction` fires one                |
+| `set-stage <instance-id> --to <stage-id>`    | stub (engine has no guard-bypass path yet)                                                |
+| `definition list`                            | wired — `client.fetch` over `workflow.definition` documents                               |
+| `definition show <id>`                       | wired — `client.fetch`, latest version unless `--version`                                 |
+| `definition diff <id>`                       | 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`)  |
 
 ## Known gaps
 

package/dist/commands/abort.js

@@ -28,7 +28,7 @@ export default class Abort extends Command {
         try {
             const result = await workflow.abortInstance({
                 client,
-                ...buildOperationArgs(config, args.instanceId, flags.reason),
+                ...buildOperationArgs({ config, instanceId: args.instanceId, reason: flags.reason }),
             });
             const report = abortReport(result);
             if (!report.fired) {

package/dist/commands/definition/delete.d.ts

@@ -21,10 +21,14 @@ export default class DefinitionDelete extends Command {
  * engine's optionals reject an explicit `undefined` under
  * `exactOptionalPropertyTypes`.
  */
-export declare function buildDeleteArgs(config: WorkflowConfig, name: string, flags: {
-    version?: number | undefined;
-    cascade: boolean;
-    reason?: string | undefined;
+export declare function buildDeleteArgs({ config, name, flags, }: {
+    config: WorkflowConfig;
+    name: string;
+    flags: {
+        version?: number | undefined;
+        cascade: boolean;
+        reason?: string | undefined;
+    };
 }): Omit<DeleteDefinitionArgs, 'client'>;
 /** What the spinner names: the workflow, or one pinned version of it. */
 export declare function deleteTargetLabel(args: Pick<DeleteDefinitionArgs, 'definition' | 'version'>): string;

package/dist/commands/definition/delete.js

@@ -36,7 +36,7 @@ export default class DefinitionDelete extends Command {
         const { args, flags } = await this.parse(DefinitionDelete);
         const config = loadWorkflowConfig(flags.tag);
         const client = loadClient();
-        const deleteArgs = buildDeleteArgs(config, args.name, flags);
+        const deleteArgs = buildDeleteArgs({ config, name: args.name, flags });
         const spinner = ora(`Deleting definition ${deleteTargetLabel(deleteArgs)}…`).start();
         try {
             const result = await workflow.deleteDefinition({ client, ...deleteArgs });
@@ -55,7 +55,7 @@ export default class DefinitionDelete extends Command {
  * engine's optionals reject an explicit `undefined` under
  * `exactOptionalPropertyTypes`.
  */
-export function buildDeleteArgs(config, name, flags) {
+export function buildDeleteArgs({ config, name, flags, }) {
     return {
         ...baseEngineArgs(config),
         definition: name,

package/dist/commands/definition/diff.js

@@ -29,14 +29,19 @@ export default class DefinitionDiff extends Command {
         const spinner = ora(`Diffing ${args.definition} against deployed…`).start();
         let deployed;
         try {
-            deployed = await fetchDeployedDefinition(client, args.definition, config, flags.version);
-            spinner.succeed(`Diffed ${args.definition} v${def.version}`);
+            deployed = await fetchDeployedDefinition({
+                client,
+                name: args.definition,
+                config,
+                version: flags.version,
+            });
+            spinner.succeed(`Diffed ${args.definition}`);
         }
         catch (error) {
             spinner.fail('Diff failed');
             throw error;
         }
-        for (const line of diffReport([diffEntry(def, deployed, config)]))
+        for (const line of diffReport([diffEntry({ def, latestRaw: deployed, target: config })]))
             this.log(line);
     }
 }
@@ -47,7 +52,7 @@ export default class DefinitionDiff extends Command {
  * superseded — latest unless pinned via `version`. An absent latest is a
  * legitimate "create" diff, but an absent *pinned* version is an error.
  */
-async function fetchDeployedDefinition(client, name, config, version) {
+async function fetchDeployedDefinition({ client, name, config, version, }) {
     const { groq, params } = buildDefinitionShowQuery({ name, tag: config.tag, version });
     const deployed = await client.fetch(groq, params);
     if (deployed === null && version !== undefined) {

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

@@ -2,7 +2,7 @@ import { Command } from '@oclif/core';
 import { type WorkflowRole } from '@sanity/workflow-engine';
 interface DefinitionListFlags {
     tag?: string | undefined;
-    'workflow-id'?: string | undefined;
+    'workflow-name'?: string | undefined;
     limit: number;
 }
 export interface DefinitionListRow {
@@ -24,7 +24,7 @@ export default class DefinitionList extends Command {
     static examples: string[];
     static flags: {
         limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
-        'workflow-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'workflow-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/definition/list.js

@@ -21,8 +21,8 @@ export function buildDefinitionListQuery(flags) {
         params.tag = flags.tag;
         filters.push(tagScopeFilter());
     }
-    if (flags['workflow-id']) {
-        params.name = flags['workflow-id'];
+    if (flags['workflow-name']) {
+        params.name = flags['workflow-name'];
         filters.push('name == $name');
     }
     const instanceMatch = instanceFilters.join(' && ');
@@ -50,7 +50,7 @@ export default class DefinitionList extends Command {
             description: 'The maximum number of definitions to return.',
             default: 100,
         }),
-        'workflow-id': Flags.string({
+        'workflow-name': Flags.string({
             description: 'Filter to a single workflow definition name (e.g. product-launch)',
         }),
     };

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

@@ -24,10 +24,12 @@ export default class DefinitionShow extends Command {
  *  title, then the human title, description, and deploy `tag` as aligned
  *  detail rows. `tag` is deployment metadata (the partition), not part of the
  *  authored definition, so it's passed separately and omitted when unknown. */
-export declare function definitionHeader(def: WorkflowDefinition, tag?: string): string;
+export declare function definitionHeader(def: WorkflowDefinition & {
+    version: number;
+}, tag?: string): string;
 /**
- * The body lines for `definition show`: every stage with its tasks and each
- * task's actions. Pure so it can be asserted without driving the oclif command.
+ * The body lines for `definition show`: every stage with its activities and each
+ * activity's actions. Pure so it can be asserted without driving the oclif command.
  */
 export declare function describeDefinition(def: WorkflowDefinition): string[];
 export {};

package/dist/commands/definition/show.js

@@ -36,8 +36,8 @@ export default class DefinitionShow extends Command {
             version: flags.version,
         });
         const client = loadClient();
-        // The authored {@link WorkflowDefinition} carries no `tag` — it's the
-        // partition the document was deployed into, stamped on the stored doc.
+        // A deployed document: the authored {@link WorkflowDefinition} plus the
+        // deploy-stamped envelope (`version`, `contentHash`, `tag`).
         const def = await client.fetch(groq, params);
         if (!def) {
             const at = flags.version ? `v${flags.version}` : 'latest';
@@ -57,11 +57,15 @@ const HEADER_PAD = 11; // "Description" — the longest label in the block
  *  authored definition, so it's passed separately and omitted when unknown. */
 export function definitionHeader(def, tag) {
     const rows = [
-        formatKeyValue('Title', def.title, { padTo: HEADER_PAD }),
-        formatKeyValue('Description', def.description ?? styleText('dim', '—'), { padTo: HEADER_PAD }),
+        formatKeyValue({ key: 'Title', value: def.title, padTo: HEADER_PAD }),
+        formatKeyValue({
+            key: 'Description',
+            value: def.description ?? styleText('dim', '—'),
+            padTo: HEADER_PAD,
+        }),
     ];
     if (tag !== undefined) {
-        rows.push(formatKeyValue('Tag', tag, { padTo: HEADER_PAD }));
+        rows.push(formatKeyValue({ key: 'Tag', value: tag, padTo: HEADER_PAD }));
     }
     return [styleText('bold', `${def.name} v${def.version}`), ...rows].join('\n');
 }
@@ -71,24 +75,24 @@ function actionLine(action) {
     const status = statusOp ? styleText('dim', ` → ${statusOp.status}`) : '';
     return `          · ${action.name}${status}`;
 }
-/** A `- task` line followed by one line per action it exposes. */
-function taskBlock(task) {
-    const title = task.title ? styleText('dim', ` — ${task.title}`) : '';
-    return [`      - ${task.name}${title}`, ...(task.actions ?? []).map(actionLine)];
+/** A `- activity` line followed by one line per action it exposes. */
+function activityBlock(activity) {
+    const title = activity.title ? styleText('dim', ` — ${activity.title}`) : '';
+    return [`      - ${activity.name}${title}`, ...(activity.actions ?? []).map(actionLine)];
 }
-/** A `• stage` line (with initial/terminal markers) followed by its task blocks. */
+/** A `• stage` line (with initial/terminal markers) followed by its activity blocks. */
 function stageBlock(stage, initialStage) {
     const title = stage.title ? styleText('dim', ` — ${stage.title}`) : '';
     const terminal = isTerminalStage(stage) ? styleText('dim', ' (terminal)') : '';
     const initial = stage.name === initialStage ? styleText('cyan', '  [initial]') : '';
     return [
         `  • ${stage.name}${title}${terminal}${initial}`,
-        ...(stage.tasks ?? []).flatMap(taskBlock),
+        ...(stage.activities ?? []).flatMap(activityBlock),
     ];
 }
 /**
- * The body lines for `definition show`: every stage with its tasks and each
- * task's actions. Pure so it can be asserted without driving the oclif command.
+ * The body lines for `definition show`: every stage with its activities and each
+ * activity's actions. Pure so it can be asserted without driving the oclif command.
  */
 export function describeDefinition(def) {
     return [

package/dist/commands/deploy.js

@@ -41,12 +41,12 @@ export default class Deploy extends Command {
         }
         const client = loadClient();
         if (flags['dry-run']) {
-            await this.runDryRun(client, selected, config);
+            await this.runDryRun({ client, defs: selected, config });
             return;
         }
-        await this.executeDeploy(client, selected, config);
+        await this.executeDeploy({ client, defs: selected, config });
     }
-    async executeDeploy(client, defs, config) {
+    async executeDeploy({ client, defs, config, }) {
         const spinner = ora(`Deploying ${defs.length} definition(s)…`).start();
         try {
             const { results } = await workflow.deployDefinitions({
@@ -64,10 +64,10 @@ export default class Deploy extends Command {
             throw error;
         }
     }
-    async runDryRun(client, defs, config) {
+    async runDryRun({ client, defs, config, }) {
         const spinner = ora(`Diffing ${defs.length} definition(s) against dataset…`).start();
         try {
-            const entries = await computeDiffEntries(client, defs, config);
+            const entries = await computeDiffEntries({ client, defs, target: config });
             spinner.succeed(`Diffed ${defs.length} definition(s)`);
             for (const line of diffReport(entries))
                 this.log(line);
@@ -88,7 +88,6 @@ export function validateModeFlags(check, dryRun) {
 export function deployResultLines(results) {
     const symbols = {
         created: logSymbols.success,
-        updated: logSymbols.info,
     };
     return results.map((r) => {
         const symbol = symbols[r.status] ?? logSymbols.warning;

package/dist/commands/diagnose.d.ts

@@ -1,14 +1,18 @@
 import { Command } from '@oclif/core';
 import { type Diagnosis, type DiagnoseInput, type SuggestedRemediation } from '@sanity/workflow-engine';
 /**
- * The diagnosis body: the verdict line, the current stage's tasks +
+ * 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 declare function renderDiagnosis(diagnosis: Diagnosis, input: DiagnoseInput, remediations: SuggestedRemediation[]): string[];
+export declare function renderDiagnosis({ diagnosis, input, remediations, }: {
+    diagnosis: Diagnosis;
+    input: DiagnoseInput;
+    remediations: SuggestedRemediation[];
+}): string[];
 export default class Diagnose extends Command {
     static description: string;
     static examples: string[];

package/dist/commands/diagnose.js

@@ -6,25 +6,28 @@ import { loadClient } from "../lib/client.js";
 import { loadWorkflowConfig } from "../lib/config.js";
 import { fail } from "../lib/fail.js";
 import { tagFlags } from "../lib/flags.js";
-import { formatTimestamp, sectionHeader, taskIcon } from "../lib/ui.js";
+import { formatTimestamp, sectionHeader, activityIcon } from "../lib/ui.js";
 import { instanceHeader } from "./show.js";
 function formatAssignee(a) {
     return a.type === 'user' ? `user:${a.id}` : `role:${a.role}`;
 }
-function taskLine(t, assignees) {
+function activityLine(t, assignees) {
     const who = assignees.length > 0
         ? styleText('dim', `  assigned → ${assignees.map(formatAssignee).join(', ')}`)
         : '';
-    return `  ${taskIcon[t.status]} ${t.task.name} ${styleText('dim', `[${t.status}]`)}${who}`;
+    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 currentStageLines(input) {
-    const lines = [`${sectionHeader('Stage')} ${input.instance.currentStage}`, sectionHeader('Tasks')];
-    for (const t of input.tasks) {
-        lines.push(taskLine(t, input.assignees[t.task.name] ?? []));
+    const lines = [
+        `${sectionHeader('Stage')} ${input.instance.currentStage}`,
+        sectionHeader('Activities'),
+    ];
+    for (const t of input.activities) {
+        lines.push(activityLine(t, input.assignees[t.activity.name] ?? []));
     }
     if (input.transitions.length > 0) {
         lines.push('', sectionHeader('Exit transitions'));
@@ -37,14 +40,14 @@ function currentStageLines(input) {
 function failedEffectDetail(effect) {
     const ran = effect.durationMs !== undefined ? ` (after ${effect.durationMs}ms)` : '';
     return {
-        headline: `a failed effect is blocking task '${effect.origin.name}'`,
+        headline: `a failed effect is blocking activity '${effect.origin.name}'`,
         why: [
             styleText('red', `${logSymbols.error} failed effect: ${effect.name}`),
-            `  queued by task '${effect.origin.name}', failed ${formatTimestamp(effect.ranAt)}${ran}`,
+            `  queued by activity '${effect.origin.name}', failed ${formatTimestamp(effect.ranAt)}${ran}`,
             ...(effect.error !== undefined ? [`  error: ${effect.error.message}`] : []),
             '',
-            `Task '${effect.origin.name}' is waiting on this effect. It failed against an`,
-            `external system, so the task never completes and the stage can't advance.`,
+            `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.`,
         ],
     };
 }
@@ -58,12 +61,12 @@ function hungEffectDetail(effect) {
         ],
     };
 }
-function failedTaskDetail(task) {
+function failedActivityDetail(activity) {
     return {
-        headline: `task '${task}' failed`,
+        headline: `activity '${activity}' failed`,
         why: [
-            styleText('red', `${logSymbols.error} task '${task}' is in a terminal failed state.`),
-            `Any exit transition gated on '${task}' being done can never fire.`,
+            styleText('red', `${logSymbols.error} activity '${activity}' is in a terminal failed state.`),
+            `Any exit transition gated on '${activity}' being done can never fire.`,
         ],
     };
 }
@@ -76,31 +79,31 @@ function waitingLines(w) {
         ? `assigned to ${w.assignees.map(formatAssignee).join(', ')}`
         : 'unassigned — anyone with permission can act';
     return [
-        `${logSymbols.info} task '${w.task}' is active (${who}),`,
+        `${logSymbols.info} activity '${w.activity}' is active (${who}),`,
         `waiting for action: ${w.actions.join(' or ')}. This is the normal in-flight`,
         `state — it advances when someone acts.`,
     ];
 }
 function blockedHeadline(b) {
     const who = b.assignees.length > 0 ? ` for ${b.assignees.map(formatAssignee).join(', ')}` : '';
-    return `task '${b.task}'${who} is not yet ready — unmet requirement(s): ${b.requirements.join(', ')}`;
+    return `activity '${b.activity}'${who} is not yet ready — unmet requirement(s): ${b.requirements.join(', ')}`;
 }
 function blockedLines(b) {
     const who = b.assignees.length > 0
         ? `assigned to ${b.assignees.map(formatAssignee).join(', ')}`
         : 'unassigned';
     return [
-        `${logSymbols.info} task '${b.task}' is visible but not yet executable (${who}).`,
+        `${logSymbols.info} activity '${b.activity}' is visible but not yet executable (${who}).`,
         `Unmet requirement(s): ${b.requirements.join(', ')}. It can't be acted on until`,
         `those preconditions are met — check what would satisfy them (a prerequisite`,
-        `task completing, required content landing). It will not advance on its own.`,
+        `activity completing, required content landing). It will not advance on its own.`,
     ];
 }
 function noTransitionDetail() {
     return {
         headline: `no exit transition's filter is satisfied`,
         why: [
-            `${logSymbols.info} every task is resolved, but no exit transition's filter is true.`,
+            `${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.`,
         ],
     };
@@ -114,7 +117,7 @@ function transitionUnevaluableDetail(transitions) {
     return {
         headline: `an exit transition's filter could not be evaluated`,
         why: [
-            `${logSymbols.info} every task is resolved, but ${transitions.join(', ')} reads an operand`,
+            `${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`,
             `subject (or fill the field) — and the instance advances on its own; no`,
@@ -125,7 +128,7 @@ function transitionUnevaluableDetail(transitions) {
 const REMEDIATION_LABEL = {
     'retry-effect': 'retry-effect',
     'drain-effects': 're-run the effect drainer',
-    'reset-task': 'reset-task',
+    'reset-activity': 'reset-activity',
     'set-stage': 'move-stage',
     abort: 'abort',
 };
@@ -142,8 +145,8 @@ function causeDetail(cause) {
             return failedEffectDetail(cause.effect);
         case 'hung-effect':
             return hungEffectDetail(cause.effect);
-        case 'failed-task':
-            return failedTaskDetail(cause.task);
+        case 'failed-activity':
+            return failedActivityDetail(cause.activity);
         case 'no-transition-fires':
             return noTransitionDetail();
         case 'transition-unevaluable':
@@ -169,14 +172,14 @@ function statusLine(diagnosis) {
     }
 }
 /**
- * The diagnosis body: the verdict line, the current stage's tasks +
+ * 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 renderDiagnosis({ diagnosis, input, remediations, }) {
     const lines = [statusLine(diagnosis)];
     const inFlight = diagnosis.state === 'progressing' ||
         diagnosis.state === 'waiting' ||
@@ -232,7 +235,7 @@ export default class Diagnose extends Command {
             workflowResource: config.workflowResource,
             instanceId: args.instanceId,
             // Token-auth CLI can't hit /users/me; pin the same system actor the
-            // write verbs use. Transition filters and task status are actor-
+            // 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
@@ -252,7 +255,7 @@ export default class Diagnose extends Command {
         }
         this.log(instanceHeader(evaluation.instance));
         this.log('');
-        for (const line of renderDiagnosis(diagnosis, input, remediations)) {
+        for (const line of renderDiagnosis({ diagnosis, input, remediations })) {
             this.log(line);
         }
     }

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

@@ -9,12 +9,16 @@ import { type RanOp } from '../lib/ops-report.ts';
  */
 export declare function parseParams(pairs: string[]): Record<string, unknown>;
 /**
- * The list-mode body: every action on the current stage's tasks, marked
+ * 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 declare function renderAvailableActions(actions: AvailableAction[], stage: string, instanceId: string): string[];
+export declare function renderAvailableActions({ actions, stage, instanceId, }: {
+    actions: AvailableAction[];
+    stage: string;
+    instanceId: string;
+}): string[];
 interface FireOutcome {
     fired: boolean;
     cascaded: number;
@@ -27,7 +31,7 @@ interface FireOutcome {
  *  {@link fireActionReport}. Pure so its shape is asserted directly. */
 export declare function fireResultJson(result: FireOutcome, ids: {
     instanceId: string;
-    task: string;
+    activity: string;
     action: string;
 }): Record<string, unknown>;
 export interface FireActionReport {
@@ -40,7 +44,11 @@ export interface FireActionReport {
  * the fired / no-op / cascaded / ops permutations assert without a live
  * fire.
  */
-export declare function fireActionReport(result: FireOutcome, task: string, action: string): FireActionReport;
+export declare function fireActionReport({ result, activity, action, }: {
+    result: FireOutcome;
+    activity: string;
+    action: string;
+}): FireActionReport;
 export default class FireAction extends Command {
     static description: string;
     static examples: string[];
@@ -48,7 +56,7 @@ export default class FireAction extends Command {
         instanceId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
-        task: import("@oclif/core/interfaces").OptionFlag<string | undefined, 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>;
         as: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;