@sanity/workflow-cli 0.7.1 → 0.8.1

package/dist/commands/fire-action.js

@@ -44,8 +44,8 @@ function reasonText(reason) {
     switch (reason.kind) {
         case 'filter-failed':
             return `action filter not satisfied${reason.detail ? ` (${reason.detail})` : ''}`;
-        case 'task-not-active':
-            return `task is ${reason.status}`;
+        case 'activity-not-active':
+            return `activity is ${reason.status}`;
         case 'stage-terminal':
             return `stage '${reason.stage}' is terminal`;
         case 'mutation-guard-denied':
@@ -63,7 +63,7 @@ function actionLines(a) {
     const mark = a.allowed ? logSymbols.success : logSymbols.error;
     const title = a.title !== undefined ? styleText('dim', `  (${a.title})`) : '';
     const lines = [
-        `  ${mark} ${a.task} → ${a.action}${title} ${styleText('dim', `[task ${a.taskStatus}]`)}`,
+        `  ${mark} ${a.activity} → ${a.action}${title} ${styleText('dim', `[activity ${a.activityStatus}]`)}`,
     ];
     if (a.params.length > 0) {
         lines.push(styleText('dim', `      params: ${a.params.map(paramLabel).join(', ')}`));
@@ -74,20 +74,20 @@ function actionLines(a) {
     return lines;
 }
 /**
- * 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 function renderAvailableActions(actions, stage, instanceId) {
+export function renderAvailableActions({ actions, stage, instanceId, }) {
     if (actions.length === 0) {
-        return [`No actions on the tasks of the current stage ('${stage}').`];
+        return [`No actions on the activities of the current stage ('${stage}').`];
     }
     const lines = [styleText('bold', `Actions on stage '${stage}':`), ''];
     for (const a of actions) {
         lines.push(...actionLines(a));
     }
-    lines.push('', styleText('dim', 'Fire one with:'), styleText('dim', `  fire-action ${instanceId} --task <task> --action <action>`));
+    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
@@ -95,7 +95,7 @@ export function renderAvailableActions(actions, stage, instanceId) {
 export function fireResultJson(result, ids) {
     return {
         instanceId: ids.instanceId,
-        task: ids.task,
+        activity: ids.activity,
         action: ids.action,
         fired: result.fired,
         cascaded: result.cascaded,
@@ -108,37 +108,37 @@ export function fireResultJson(result, ids) {
  * the fired / no-op / cascaded / ops permutations assert without a live
  * fire.
  */
-export function fireActionReport(result, task, action) {
+export function fireActionReport({ result, activity, action, }) {
     const stage = styleText('bold', result.instance.currentStage);
     if (!result.fired) {
         return {
             fired: false,
-            message: `fireAction returned without firing — task '${task}' is no longer active`,
+            message: `fireAction returned without firing — activity '${activity}' is no longer active`,
             opsLines: [],
         };
     }
     const tail = result.cascaded > 0 ? `, then cascaded ${result.cascaded} auto-transition(s)` : '';
     return {
         fired: true,
-        message: `Fired ${styleText('bold', action)} on ${styleText('bold', task)} — now at ${stage}${tail}`,
+        message: `Fired ${styleText('bold', action)} on ${styleText('bold', activity)} — now at ${stage}${tail}`,
         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 task. Omit --action to list what can be fired.";
+    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.";
     static examples = [
         '<%= config.bin %> fire-action wf-instance.abc123',
-        '<%= config.bin %> fire-action wf-instance.abc123 --task approve --action approve',
-        '<%= config.bin %> fire-action wf-instance.abc123 --task approve --action approve --as user.xyz --as-role editor',
-        '<%= config.bin %> fire-action wf-instance.abc123 --task publish --action publish --param note=shipping',
+        '<%= 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 = {
         instanceId: Args.string({ required: true, description: 'Workflow instance id.' }),
     };
     static flags = {
         ...tagFlags,
-        task: Flags.string({
-            description: 'Task the action belongs to. Required to fire; omit --action to list.',
+        activity: Flags.string({
+            description: 'Activity the action belongs to. Required to fire; omit --action to list.',
         }),
         action: Flags.string({
             description: 'Action to fire. Omit to list the actions available on the instance.',
@@ -167,24 +167,24 @@ export default class FireAction extends Command {
         const client = loadClient();
         const actor = failOnThrow('fire-action usage error:', () => resolveActor(flags.as, flags['as-role']));
         if (flags.action === undefined) {
-            await this.listActions(client, config, args.instanceId, actor, flags.json);
+            await this.listActions({ client, config, instanceId: args.instanceId, actor, json: flags.json });
             return;
         }
-        if (flags.task === undefined) {
-            fail('fire-action usage error:', 'specify --task for the action (or omit --action to list what can be fired)');
+        if (flags.activity === undefined) {
+            fail('fire-action usage error:', 'specify --activity for the action (or omit --action to list what can be fired)');
         }
         await this.fireOne({
             client,
             config,
             instanceId: args.instanceId,
             actor,
-            task: flags.task,
+            activity: flags.activity,
             action: flags.action,
             params: flags.param,
             json: flags.json,
         });
     }
-    async listActions(client, config, instanceId, actor, json) {
+    async listActions({ client, config, instanceId, actor, json, }) {
         const { evaluation, actions } = await workflow
             .availableActions({
             client,
@@ -201,19 +201,19 @@ export default class FireAction extends Command {
         }
         this.log(instanceHeader(evaluation.instance));
         this.log('');
-        for (const line of renderAvailableActions(actions, stage, instanceId)) {
+        for (const line of renderAvailableActions({ actions, stage, instanceId })) {
             this.log(line);
         }
     }
     async fireOne(opts) {
-        const { client, config, instanceId, actor, task, action, json } = opts;
+        const { client, config, instanceId, actor, activity, action, json } = opts;
         const params = failOnThrow('Invalid --param:', () => parseParams(opts.params));
         const fireArgs = {
             client,
             tag: config.tag,
             workflowResource: config.workflowResource,
             instanceId,
-            task,
+            activity,
             action,
             access: { actor },
             params,
@@ -222,13 +222,17 @@ export default class FireAction extends Command {
             const result = await workflow
                 .fireAction(fireArgs)
                 .catch((error) => fail('fireAction error:', errorMessage(error)));
-            this.log(JSON.stringify(fireResultJson(result, { instanceId, task, action }), null, 2));
+            this.log(JSON.stringify(fireResultJson(result, { instanceId, activity, action }), null, 2));
             return;
         }
-        const spinner = ora(`Firing ${action} on ${task}…`).start();
+        const spinner = ora(`Firing ${action} on ${activity}…`).start();
         try {
             const result = await workflow.fireAction(fireArgs);
-            emitWriteReport(spinner, fireActionReport(result, task, action), (line) => this.log(line));
+            emitWriteReport({
+                spinner,
+                report: fireActionReport({ result, activity, action }),
+                log: (line) => this.log(line),
+            });
         }
         catch (error) {
             spinner.fail('Action rejected');

package/dist/commands/list.d.ts

@@ -12,7 +12,7 @@ type InstanceStatus = 'aborted' | 'completed' | 'in-flight';
 interface ListFlags {
     'in-flight': boolean;
     failed: boolean;
-    'workflow-id'?: string | undefined;
+    'workflow-name'?: string | undefined;
     tag?: string | undefined;
     limit: number;
 }
@@ -41,7 +41,7 @@ export default class List extends Command {
     static flags: {
         'in-flight': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         failed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        '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>;
         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>;
     };

package/dist/commands/list.js

@@ -15,11 +15,11 @@ export function buildListQuery(flags) {
     const filters = [`_type == "${WORKFLOW_INSTANCE_TYPE}"`];
     if (flags['in-flight'])
         filters.push('!defined(completedAt)');
-    if (flags['workflow-id'])
+    if (flags['workflow-name'])
         filters.push('definition == $definition');
-    // Cheap approximation of --failed: any task in any stage with status "failed".
+    // Cheap approximation of --failed: any activity in any stage with status "failed".
     if (flags.failed)
-        filters.push('count(stages[].tasks[status == "failed"]) > 0');
+        filters.push('count(stages[].activities[status == "failed"]) > 0');
     if (flags.tag)
         filters.push(tagScopeFilter());
     const groq = `*[${filters.join(' && ')}] | order(lastChangedAt desc) [0...$limit]{
@@ -32,8 +32,8 @@ export function buildListQuery(flags) {
       lastChangedAt
     }`;
     const params = { limit: flags.limit };
-    if (flags['workflow-id'])
-        params['definition'] = flags['workflow-id'];
+    if (flags['workflow-name'])
+        params['definition'] = flags['workflow-name'];
     if (flags.tag)
         params['tag'] = flags.tag;
     return { groq, params };
@@ -68,7 +68,7 @@ export default class List extends Command {
     static examples = [
         '<%= config.bin %> list',
         '<%= config.bin %> list --in-flight',
-        '<%= config.bin %> list --workflow-id productLaunch',
+        '<%= config.bin %> list --workflow-name productLaunch',
         '<%= config.bin %> list --tag prod',
     ];
     static flags = {
@@ -78,10 +78,10 @@ export default class List extends Command {
             default: false,
         }),
         failed: Flags.boolean({
-            description: 'Only instances with at least one failed task.',
+            description: 'Only instances with at least one failed activity.',
             default: false,
         }),
-        'workflow-id': Flags.string({
+        'workflow-name': Flags.string({
             description: 'Filter by workflow definition name.',
         }),
         limit: Flags.integer({

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

@@ -17,7 +17,12 @@ export default class MoveStage extends Command {
 }
 /** The shared operation args ({@link buildOperationArgs}) plus the
  *  setStage-specific target. */
-export declare function buildSetStageArgs(config: WorkflowConfig, instanceId: string, targetStage: string, reason: string | undefined): Omit<SetStageArgs, 'client'>;
+export declare function buildSetStageArgs({ config, instanceId, targetStage, reason, }: {
+    config: WorkflowConfig;
+    instanceId: string;
+    targetStage: string;
+    reason: string | undefined;
+}): Omit<SetStageArgs, 'client'>;
 interface SetStageOutcome {
     fired: boolean;
     cascaded: number;

package/dist/commands/move-stage.js

@@ -38,9 +38,18 @@ export default class MoveStage extends Command {
         try {
             const result = await workflow.setStage({
                 client,
-                ...buildSetStageArgs(config, args.instanceId, flags.to, flags.reason),
+                ...buildSetStageArgs({
+                    config,
+                    instanceId: args.instanceId,
+                    targetStage: flags.to,
+                    reason: flags.reason,
+                }),
+            });
+            emitWriteReport({
+                spinner,
+                report: moveStageReport(result, flags.to),
+                log: (line) => this.log(line),
             });
-            emitWriteReport(spinner, moveStageReport(result, flags.to), (line) => this.log(line));
         }
         catch (error) {
             spinner.fail('Move rejected');
@@ -51,8 +60,8 @@ export default class MoveStage extends Command {
 }
 /** The shared operation args ({@link buildOperationArgs}) plus the
  *  setStage-specific target. */
-export function buildSetStageArgs(config, instanceId, targetStage, reason) {
-    return { ...buildOperationArgs(config, instanceId, reason), targetStage };
+export function buildSetStageArgs({ config, instanceId, targetStage, reason, }) {
+    return { ...buildOperationArgs({ config, instanceId, reason }), targetStage };
 }
 /**
  * Turn a `setStage` result into the spinner message + ops block. Pure so

package/dist/commands/{retry-task.d.ts → retry-activity.d.ts}

@@ -1,9 +1,9 @@
 import { StubCommand } from '../lib/stub.ts';
-export default class RetryTask extends StubCommand {
+export default class RetryActivity extends StubCommand {
     static hidden: boolean;
     static description: string;
     static args: {
         instanceId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-        task: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        activity: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
 }

package/dist/commands/{retry-task.js → retry-activity.js}

@@ -1,11 +1,11 @@
 import { Args } from '@oclif/core';
 import { StubCommand } from "../lib/stub.js";
-export default class RetryTask extends StubCommand {
+export default class RetryActivity extends StubCommand {
     // Stubbed, so kept off the help + published surface until it's wired.
     static hidden = true;
-    static description = 'Re-invoke a failed task on an in-flight instance.';
+    static description = 'Re-invoke a failed activity on an in-flight instance.';
     static args = {
         instanceId: Args.string({ required: true, description: 'Workflow instance id.' }),
-        task: Args.string({ required: true, description: 'Task name within the current stage.' }),
+        activity: Args.string({ required: true, description: 'Activity name within the current stage.' }),
     };
 }

package/dist/commands/set-stage.js

@@ -4,7 +4,7 @@ export default class SetStage extends StubCommand {
     // Stubbed, so kept off the help + published surface until it's wired.
     static hidden = true;
     // Engine note: workflow.setStage currently always runs guards + stage
-    // entry (task activation, effects). A "manual override" that bypasses
+    // entry (activity activation, effects). A "manual override" that bypasses
     // them is engine work that hasn't landed; this command stub captures
     // the intended surface only.
     static description = "Force-set an instance's current stage, bypassing guards + effects (manual override).";

package/dist/commands/show.d.ts

@@ -15,7 +15,7 @@ export default class Show extends Command {
  *  `fire-action`): a bold workflow + id title, then aligned detail rows. */
 export declare function instanceHeader(instance: WorkflowInstance): string;
 /**
- * The per-instance body lines: every stage with its tasks, any pending
+ * 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.
  */

package/dist/commands/show.js

@@ -3,9 +3,9 @@ import { Args, Command, Flags } from '@oclif/core';
 import { abortReason } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
 import { loadClient } from "../lib/client.js";
-import { formatKeyValue, formatTimestamp, sectionHeader, taskIcon } from "../lib/ui.js";
+import { formatKeyValue, formatTimestamp, sectionHeader, activityIcon } from "../lib/ui.js";
 export default class Show extends Command {
-    static description = 'Show the state, tasks, and effects of a workflow instance.';
+    static description = 'Show the state, activities, and effects of a workflow instance.';
     static examples = [
         '<%= config.bin %> show wf-instance.abc123',
         '<%= config.bin %> show wf-instance.abc123 --include history',
@@ -46,8 +46,8 @@ const HEADER_PAD = 9; // "Completed" — the longest label in the block
 export function instanceHeader(instance) {
     const title = `${styleText('bold', `${instance.definition} v${instance.pinnedVersion}`)}  ${styleText('cyan', instance._id)}`;
     const rows = [
-        formatKeyValue('Stage', instance.currentStage, { padTo: HEADER_PAD }),
-        formatKeyValue('Started', formatTimestamp(instance.startedAt), { padTo: HEADER_PAD }),
+        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
@@ -56,19 +56,19 @@ export function instanceHeader(instance) {
         const reason = abortReason(instance);
         const tail = reason ? ` — ${reason}` : '';
         const value = styleText('yellow', `${formatTimestamp(instance.abortedAt)}${tail}`);
-        rows.push(formatKeyValue('Aborted', value, { padTo: HEADER_PAD }));
+        rows.push(formatKeyValue({ key: 'Aborted', value, padTo: HEADER_PAD }));
     }
     else {
         const completed = instance.completedAt
             ? styleText('green', formatTimestamp(instance.completedAt))
             : styleText('dim', '—');
-        rows.push(formatKeyValue('Completed', completed, { padTo: HEADER_PAD }));
+        rows.push(formatKeyValue({ key: 'Completed', value: completed, padTo: HEADER_PAD }));
     }
-    rows.push(formatKeyValue('Tag', instance.tag, { padTo: HEADER_PAD }));
+    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 tasks, any pending
+ * 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.
  */
@@ -79,8 +79,8 @@ export function describeInstance(instance, options) {
             ? styleText('dim', ` (exited ${formatTimestamp(stage.exitedAt)})`)
             : styleText('cyan', ' (current)');
         lines.push(`  • ${stage.name}${marker}`);
-        for (const task of stage.tasks) {
-            lines.push(`      ${taskIcon[task.status]} ${task.name}  ${styleText('dim', `[${task.status}]`)}`);
+        for (const activity of stage.activities) {
+            lines.push(`      ${activityIcon[activity.status]} ${activity.name}  ${styleText('dim', `[${activity.status}]`)}`);
         }
     }
     if (instance.pendingEffects.length > 0) {

package/dist/commands/tail.js

@@ -33,7 +33,7 @@ export default class Tail extends Command {
             .subscribe({
             next: async () => {
                 try {
-                    seen = await this.printNewEntries(client, args.instanceId, seen);
+                    seen = await this.printNewEntries({ client, instanceId: args.instanceId, seen });
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
@@ -61,7 +61,7 @@ export default class Tail extends Command {
      * given high-water mark, return the new mark. Pulled out so the
      * async work in the subscription's `next` handler stays tidy.
      */
-    async printNewEntries(client, instanceId, seen) {
+    async printNewEntries({ client, instanceId, seen, }) {
         const next = await client.getDocument(instanceId);
         if (!next)
             return seen;

package/dist/lib/definitions.js

@@ -115,7 +115,7 @@ export function collectValidationErrors(defs) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            errors.push(`  · ${d.name} v${d.version}: ${message}`);
+            errors.push(`  · ${d.name}: ${message}`);
         }
     }
     return errors;

package/dist/lib/diff.d.ts

@@ -1,5 +1,6 @@
 import type { DiffEntry } from '@sanity/workflow-engine';
-/** One summary line per diff entry, tagged create / update / unchanged. */
+/** One summary line per diff entry, tagged create / unchanged. Definitions are
+ *  immutable, so a content change is a new version (`create`), never an update. */
 export declare function summaryLines(entries: DiffEntry[]): string[];
 /** Render a JSON diff of `oldObj` → `newObj` as `+`/`-`/context lines. */
 export declare function diffLines(oldObj: object, newObj: object): string[];

package/dist/lib/diff.js

@@ -2,11 +2,11 @@ import { styleText } from 'node:util';
 import { diffJson } from 'diff';
 import logSymbols from 'log-symbols';
 import { sectionHeader } from "./ui.js";
-/** One summary line per diff entry, tagged create / update / unchanged. */
+/** One summary line per diff entry, tagged create / unchanged. Definitions are
+ *  immutable, so a content change is a new version (`create`), never an update. */
 export function summaryLines(entries) {
     const tags = {
         create: styleText('green', '+ create   '),
-        update: styleText('yellow', '~ update   '),
         unchanged: styleText('dim', '  unchanged'),
     };
     return entries.map((e) => {

package/dist/lib/operation-args.d.ts

@@ -20,6 +20,10 @@ export declare function resolveActor(as: string | undefined, roles: string[]): A
  * conditionally because the engine's optional field rejects an explicit
  * `undefined` under `exactOptionalPropertyTypes`.
  */
-export declare function buildOperationArgs(config: WorkflowConfig, instanceId: string, reason: string | undefined): Omit<OperationArgs, 'client'> & {
+export declare function buildOperationArgs({ config, instanceId, reason, }: {
+    config: WorkflowConfig;
+    instanceId: string;
+    reason: string | undefined;
+}): Omit<OperationArgs, 'client'> & {
     reason?: string;
 };

package/dist/lib/operation-args.js

@@ -39,7 +39,7 @@ export function resolveActor(as, roles) {
  * conditionally because the engine's optional field rejects an explicit
  * `undefined` under `exactOptionalPropertyTypes`.
  */
-export function buildOperationArgs(config, instanceId, reason) {
+export function buildOperationArgs({ config, instanceId, reason, }) {
     return {
         ...baseEngineArgs(config),
         instanceId,

package/dist/lib/ops-report.d.ts

@@ -27,4 +27,8 @@ export interface WriteReport {
  * Shared by every write command so the fired / not-fired branches stay
  * consistent.
  */
-export declare function emitWriteReport(spinner: Ora, report: WriteReport, log: (line: string) => void): void;
+export declare function emitWriteReport({ spinner, report, log, }: {
+    spinner: Ora;
+    report: WriteReport;
+    log: (line: string) => void;
+}): void;

package/dist/lib/ops-report.js

@@ -18,7 +18,7 @@ export function opsAppliedLines(ranOps) {
  * Shared by every write command so the fired / not-fired branches stay
  * consistent.
  */
-export function emitWriteReport(spinner, report, log) {
+export function emitWriteReport({ spinner, report, log, }) {
     if (!report.fired) {
         spinner.warn(report.message);
         return;

package/dist/lib/ui.d.ts

@@ -1,4 +1,4 @@
-import type { TaskStatus } from '@sanity/workflow-engine';
+import type { ActivityStatus } from '@sanity/workflow-engine';
 /**
  * A bold `Title:` section heading. Mirrors the Sanity CLI's `sectionHeader`
  * (name + shape) so it folds into the shared helper when this CLI merges in.
@@ -9,13 +9,15 @@ export declare function sectionHeader(title: string): string;
  * the Sanity CLI's `formatKeyValue` so it folds into the shared helper on
  * merge; pass `padTo` (the longest key's length) to align a block of rows.
  */
-export declare function formatKeyValue(key: string, value: string, options?: {
+export declare function formatKeyValue({ key, value, indent, padTo, }: {
+    key: string;
+    value: string;
     indent?: number;
     padTo?: number;
 }): string;
-/** Status glyph per task state. log-symbols ship pre-colored (green ✔, red ✖),
+/** Status glyph per activity state. log-symbols ship pre-colored (green ✔, red ✖),
  *  so those need no extra wrap; the rest carry their own state color. */
-export declare const taskIcon: Record<TaskStatus, string>;
+export declare const activityIcon: Record<ActivityStatus, string>;
 /** An engine ISO-8601 timestamp as an absolute `yyyy-MM-dd HH:mm:ss` — the
  *  Sanity CLI's audit-log format (see `backups/list`). For detail views. */
 export declare function formatTimestamp(iso: string): string;

package/dist/lib/ui.js

@@ -15,15 +15,13 @@ export function sectionHeader(title) {
  * the Sanity CLI's `formatKeyValue` so it folds into the shared helper on
  * merge; pass `padTo` (the longest key's length) to align a block of rows.
  */
-export function formatKeyValue(key, value, options) {
-    const indent = options?.indent ?? 2;
-    const padTo = options?.padTo ?? 0;
+export function formatKeyValue({ key, value, indent = 2, padTo = 0, }) {
     const paddedKey = `${key}:`.padEnd(padTo > 0 ? padTo + 1 : key.length + 1);
     return `${' '.repeat(indent)}${styleText('dim', paddedKey)} ${value}`;
 }
-/** Status glyph per task state. log-symbols ship pre-colored (green ✔, red ✖),
+/** Status glyph per activity state. log-symbols ship pre-colored (green ✔, red ✖),
  *  so those need no extra wrap; the rest carry their own state color. */
-export const taskIcon = {
+export const activityIcon = {
     done: logSymbols.success,
     active: styleText('cyan', '●'),
     pending: styleText('dim', '○'),