@sanity/workflow-cli 0.5.2 → 0.6.0

package/README.md

@@ -118,6 +118,8 @@ Mirrors the Sanity CLI's stack so the eventual plugin port is small:
 - [`@oclif/core`](https://oclif.io) for command definitions, flags,
   help.
 - `@oclif/plugin-help` for help output.
-- `ora`, `boxen`, `log-symbols`, `console-table-printer`, `picocolors`
-  for terminal UX.
+- `ora`, `boxen`, `log-symbols`, `console-table-printer` for terminal UX;
+  color comes from `node:util`'s `styleText` (no separate color dep).
+- `date-fns` for timestamp formatting (absolute for detail views, relative
+  "… ago" for list tables).
 - `diff` for the colored JSON unified diff in `deploy --dry-run`.

package/dist/commands/abort.js

@@ -1,7 +1,7 @@
+import { styleText } from 'node:util';
 import { Args, Command, Flags } from '@oclif/core';
 import { workflow } from '@sanity/workflow-engine';
 import ora from 'ora';
-import pc from 'picocolors';
 import { loadClient } from "../lib/client.js";
 import { loadWorkflowConfig } from "../lib/config.js";
 import { fail } from "../lib/fail.js";
@@ -50,7 +50,7 @@ export default class Abort extends Command {
  * a real abort.
  */
 export function abortReport(result) {
-    const stage = pc.bold(result.instance.currentStage);
+    const stage = styleText('bold', result.instance.currentStage);
     if (!result.fired) {
         const at = result.instance.completedAt ?? 'unknown';
         return {

package/dist/commands/definition/delete.js

@@ -1,7 +1,7 @@
+import { styleText } from 'node:util';
 import { Args, Command, Flags } from '@oclif/core';
 import { workflow, } from '@sanity/workflow-engine';
 import ora from 'ora';
-import pc from 'picocolors';
 import { loadClient } from "../../lib/client.js";
 import { loadWorkflowConfig } from "../../lib/config.js";
 import { fail } from "../../lib/fail.js";
@@ -75,7 +75,7 @@ export function deleteTargetLabel(args) {
  */
 export function deleteReport(result) {
     const versions = result.deletedVersions.map((v) => `v${v}`).join(', ');
-    const parts = [`Deleted ${pc.bold(result.name)} ${versions}`];
+    const parts = [`Deleted ${styleText('bold', result.name)} ${versions}`];
     if (result.abortedInstanceIds.length > 0) {
         parts.push(`aborted ${result.abortedInstanceIds.length} instance(s)`);
     }

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

@@ -1,15 +1,16 @@
 import { Command } from '@oclif/core';
+import { type WorkflowRole } from '@sanity/workflow-engine';
 interface DefinitionListFlags {
     tag?: string | undefined;
     'workflow-id'?: string | undefined;
     limit: number;
 }
 export interface DefinitionListRow {
-    _id: string;
     name: string;
     version: number;
     title: string;
     tag: string;
+    role?: WorkflowRole;
     stageCount: number;
     inFlightCount: number;
     totalInstances: number;

package/dist/commands/definition/list.js

@@ -1,5 +1,5 @@
 import { Command, Flags } from '@oclif/core';
-import { WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, tagScopeFilter, } from '@sanity/workflow-engine';
+import { WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, isStartableDefinition, tagScopeFilter, } from '@sanity/workflow-engine';
 import { Table } from 'console-table-printer';
 import logSymbols from 'log-symbols';
 import { loadClient } from "../../lib/client.js";
@@ -27,11 +27,11 @@ export function buildDefinitionListQuery(flags) {
     }
     const instanceMatch = instanceFilters.join(' && ');
     const groq = `*[${filters.join(' && ')}] | order(name asc, version desc) [0...$limit]{
-      _id,
       name,
       version,
       title,
       tag,
+      role,
       "stageCount": count(stages),
       "inFlightCount": count(*[${instanceMatch} && !defined(completedAt)]),
       "totalInstances": count(*[${instanceMatch}])
@@ -65,18 +65,33 @@ export default class DefinitionList extends Command {
         }
         const table = new Table({
             columns: [
-                { name: '_id', title: 'Definition ID', alignment: 'left' },
+                { name: 'workflow', title: 'Workflow', alignment: 'left' },
                 { name: 'title', title: 'Title', alignment: 'left' },
-                { name: 'name', title: 'Workflow', alignment: 'left' },
                 { name: 'tag', title: 'Tag', alignment: 'left' },
-                { name: 'version', title: 'Version', alignment: 'right' },
-                { name: 'stageCount', title: 'Total stages', alignment: 'right' },
-                { name: 'inFlightCount', title: 'Instances in flight', alignment: 'right' },
-                { name: 'totalInstances', title: 'Total instances', alignment: 'right' },
+                { name: 'startable', title: 'Startable', alignment: 'center' },
+                { name: 'stageCount', title: 'Stages', alignment: 'right' },
+                { name: 'inFlightCount', title: 'In flight', alignment: 'right' },
+                { name: 'totalInstances', title: 'Instances', alignment: 'right' },
             ],
         });
         for (const r of rows) {
-            table.addRow(r);
+            // The doc `_id` is `tag.name.vN`, so a Definition ID column would just
+            // repeat Workflow + Tag — and no command takes an `_id` anyway (they take
+            // name + --tag/--version). `name vN` is this CLI's identifier format (the
+            // `definition show` title). Only declared keys are passed — console-table-
+            // printer renders any extra key as a stray column.
+            //
+            // `child`-role defs are spawn-only; the Startable column tells an admin
+            // which definitions a human can actually start standalone.
+            table.addRow({
+                workflow: `${r.name} v${r.version}`,
+                title: r.title,
+                tag: r.tag,
+                startable: isStartableDefinition(r) ? 'yes' : 'spawn-only',
+                stageCount: r.stageCount,
+                inFlightCount: r.inFlightCount,
+                totalInstances: r.totalInstances,
+            });
         }
         table.printTable();
     }

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

@@ -20,11 +20,11 @@ export default class DefinitionShow extends Command {
     };
     run(): Promise<void>;
 }
-/**
- * The boxed summary block at the top of `definition show` output. `columns`
- * is the terminal width; values wrap to fit it so `boxen` never re-wraps them.
- */
-export declare function definitionHeader(def: WorkflowDefinition, columns?: number): string;
+/** The summary block at the top of `definition show`: a bold name + version
+ *  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;
 /**
  * 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.

package/dist/commands/definition/show.js

@@ -1,9 +1,10 @@
+import { styleText } from 'node:util';
 import { Args, Command, Flags } from '@oclif/core';
 import { isTerminalStage, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, } from '@sanity/workflow-engine';
-import boxen from 'boxen';
 import logSymbols from 'log-symbols';
 import { loadClient } from "../../lib/client.js";
 import { tagFlags } from "../../lib/flags.js";
+import { formatKeyValue, sectionHeader } from "../../lib/ui.js";
 export function buildDefinitionShowQuery(flags) {
     const params = { name: flags.name };
     const filters = [`_type == "${WORKFLOW_DEFINITION_TYPE}"`, 'name == $name'];
@@ -35,75 +36,51 @@ 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.
         const def = await client.fetch(groq, params);
         if (!def) {
             const at = flags.version ? `v${flags.version}` : 'latest';
             this.error(`${logSymbols.error} no definition "${args.name}" (${at})`, { exit: 1 });
         }
-        this.log(boxen(definitionHeader(def, process.stdout.columns), {
-            padding: 1,
-            borderStyle: 'round',
-            title: 'definition',
-        }));
+        this.log(definitionHeader(def, def.tag));
         this.log('');
         for (const line of describeDefinition(def)) {
             this.log(line);
         }
     }
 }
-const LABEL_WIDTH = 19;
-/**
- * One `label  value` row, wrapping the value to `valueWidth` columns and
- * hanging-indenting continuation lines under the value column — so a long
- * value (the description) stays right of the label instead of bleeding back
- * to the left edge of the box.
- */
-function wrapField(label, value, valueWidth) {
-    const lines = value.split(/\s+/).reduce((acc, word) => {
-        const last = acc[acc.length - 1];
-        if (last !== undefined && last.length + 1 + word.length <= valueWidth) {
-            acc[acc.length - 1] = `${last} ${word}`;
-        }
-        else {
-            acc.push(word);
-        }
-        return acc;
-    }, []);
-    const indent = ' '.repeat(LABEL_WIDTH);
-    return lines
-        .map((text, i) => (i === 0 ? `${label.padEnd(LABEL_WIDTH)}${text}` : `${indent}${text}`))
-        .join('\n');
-}
-/**
- * The boxed summary block at the top of `definition show` output. `columns`
- * is the terminal width; values wrap to fit it so `boxen` never re-wraps them.
- */
-export function definitionHeader(def, columns = 80) {
-    const valueWidth = Math.max(columns - LABEL_WIDTH - 8, 24);
-    const field = (label, value) => wrapField(label, value, valueWidth);
-    return [
-        `${logSymbols.info} ${def.name}`,
-        field('workflow:', `${def.name} v${def.version}`),
-        field('title:', def.title),
-        field('description:', def.description ?? '—'),
-    ].join('\n');
+const HEADER_PAD = 11; // "Description" — the longest label in the block
+/** The summary block at the top of `definition show`: a bold name + version
+ *  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 function definitionHeader(def, tag) {
+    const rows = [
+        formatKeyValue('Title', def.title, { padTo: HEADER_PAD }),
+        formatKeyValue('Description', def.description ?? styleText('dim', '—'), { padTo: HEADER_PAD }),
+    ];
+    if (tag !== undefined) {
+        rows.push(formatKeyValue('Tag', tag, { padTo: HEADER_PAD }));
+    }
+    return [styleText('bold', `${def.name} v${def.version}`), ...rows].join('\n');
 }
 /** One `· action` line, annotated with the terminal status its `status.set` op sets, if any. */
 function actionLine(action) {
     const statusOp = (action.ops ?? []).find((op) => op.type === 'status.set');
-    const status = statusOp ? ` → ${statusOp.status}` : '';
+    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 ? ` — ${task.title}` : '';
+    const title = task.title ? styleText('dim', ` — ${task.title}`) : '';
     return [`      - ${task.name}${title}`, ...(task.actions ?? []).map(actionLine)];
 }
 /** A `• stage` line (with initial/terminal markers) followed by its task blocks. */
 function stageBlock(stage, initialStage) {
-    const title = stage.title ? ` — ${stage.title}` : '';
-    const terminal = isTerminalStage(stage) ? ' (terminal)' : '';
-    const initial = stage.name === initialStage ? '  [initial]' : '';
+    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),
@@ -114,5 +91,8 @@ function stageBlock(stage, initialStage) {
  * task's actions. Pure so it can be asserted without driving the oclif command.
  */
 export function describeDefinition(def) {
-    return ['stages:', ...def.stages.flatMap((stage) => stageBlock(stage, def.initialStage))];
+    return [
+        sectionHeader('Stages'),
+        ...def.stages.flatMap((stage) => stageBlock(stage, def.initialStage)),
+    ];
 }

package/dist/commands/diagnose.js

@@ -1,38 +1,33 @@
+import { styleText } from 'node:util';
 import { Args, Command, Flags } from '@oclif/core';
 import { diagnoseInputFromEvaluation, workflow, } from '@sanity/workflow-engine';
-import boxen from 'boxen';
 import logSymbols from 'log-symbols';
-import pc from 'picocolors';
 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 { instanceHeader } from "./show.js";
-const TASK_ICON = {
-    done: pc.green(logSymbols.success),
-    active: pc.cyan('●'),
-    pending: pc.dim('○'),
-    failed: pc.red(logSymbols.error),
-    skipped: pc.dim('⊘'),
-};
 function formatAssignee(a) {
     return a.type === 'user' ? `user:${a.id}` : `role:${a.role}`;
 }
 function taskLine(t, assignees) {
-    const who = assignees.length > 0 ? pc.dim(`  assigned → ${assignees.map(formatAssignee).join(', ')}`) : '';
-    return `  ${TASK_ICON[t.status]} ${t.task.name} ${pc.dim(`[${t.status}]`)}${who}`;
+    const who = assignees.length > 0
+        ? styleText('dim', `  assigned → ${assignees.map(formatAssignee).join(', ')}`)
+        : '';
+    return `  ${taskIcon[t.status]} ${t.task.name} ${styleText('dim', `[${t.status}]`)}${who}`;
 }
 function transitionLine(tr) {
-    const mark = tr.filterSatisfied ? pc.green('ready') : pc.red('false');
-    return `  → ${tr.transition.to}  ${pc.dim(tr.transition.filter ?? 'true')}  ${mark}`;
+    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 = [pc.bold(`stage: ${input.instance.currentStage}`), 'tasks:'];
+    const lines = [`${sectionHeader('Stage')} ${input.instance.currentStage}`, sectionHeader('Tasks')];
     for (const t of input.tasks) {
         lines.push(taskLine(t, input.assignees[t.task.name] ?? []));
     }
     if (input.transitions.length > 0) {
-        lines.push('', 'exit transitions:');
+        lines.push('', sectionHeader('Exit transitions'));
         for (const tr of input.transitions) {
             lines.push(transitionLine(tr));
         }
@@ -44,8 +39,8 @@ function failedEffectDetail(effect) {
     return {
         headline: `a failed effect is blocking task '${effect.origin.name}'`,
         why: [
-            pc.red(`${logSymbols.error} failed effect: ${effect.name}`),
-            `  queued by task '${effect.origin.name}', failed ${effect.ranAt}${ran}`,
+            styleText('red', `${logSymbols.error} failed effect: ${effect.name}`),
+            `  queued by task '${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`,
@@ -57,8 +52,8 @@ function hungEffectDetail(effect) {
     return {
         headline: `effect '${effect.name}' was claimed but never completed`,
         why: [
-            pc.yellow(`${logSymbols.warning} hung effect: ${effect.name}`),
-            `  claimed ${effect.claim?.claimedAt ?? '?'} but never reported back — the`,
+            styleText('yellow', `${logSymbols.warning} hung effect: ${effect.name}`),
+            `  claimed ${formatTimestamp(effect.claim?.claimedAt ?? '?')} but never reported back — the`,
             `  drainer likely died mid-dispatch, so it won't drain on its own.`,
         ],
     };
@@ -67,7 +62,7 @@ function failedTaskDetail(task) {
     return {
         headline: `task '${task}' failed`,
         why: [
-            pc.red(`${logSymbols.error} task '${task}' is in a terminal failed state.`),
+            styleText('red', `${logSymbols.error} task '${task}' is in a terminal failed state.`),
             `Any exit transition gated on '${task}' being done can never fire.`,
         ],
     };
@@ -135,13 +130,11 @@ const REMEDIATION_LABEL = {
     abort: 'abort',
 };
 /** Render the engine's structured remediations as the "suggested fix" block.
- *  An unavailable verb is dimmed and marked `(planned)` — describable but not
- *  yet runnable from the CLI. */
+ *  Only the runnable ones reach here — {@link renderDiagnosis} filters out
+ *  verbs the CLI can't yet perform so it never advertises a fix you can't run
+ *  (the full set, planned verbs included, still rides `--json`). */
 function remediationLines(remediations) {
-    return remediations.map((r) => {
-        const planned = r.available ? '' : pc.dim(' (planned)');
-        return `  • ${REMEDIATION_LABEL[r.verb]}${planned} — ${r.rationale}`;
-    });
+    return remediations.map((r) => `  • ${REMEDIATION_LABEL[r.verb]} — ${r.rationale}`);
 }
 function causeDetail(cause) {
     switch (cause.kind) {
@@ -160,19 +153,19 @@ function causeDetail(cause) {
 function statusLine(diagnosis) {
     switch (diagnosis.state) {
         case 'progressing':
-            return `${logSymbols.success} ${pc.green('progressing')} — this instance will advance on its own.`;
+            return `${logSymbols.success} ${styleText('green', 'progressing')} — this instance will advance on its own.`;
         case 'waiting':
-            return `${logSymbols.info} ${pc.cyan('waiting')} — ${waitingHeadline(diagnosis)}`;
+            return `${logSymbols.info} ${styleText('cyan', 'waiting')} — ${waitingHeadline(diagnosis)}`;
         case 'blocked':
-            return `${logSymbols.info} ${pc.cyan('blocked')} — ${blockedHeadline(diagnosis)}`;
+            return `${logSymbols.info} ${styleText('cyan', 'blocked')} — ${blockedHeadline(diagnosis)}`;
         case 'completed':
-            return `${logSymbols.success} ${pc.green('completed')} at ${diagnosis.at}.`;
+            return `${logSymbols.success} ${styleText('green', 'completed')} at ${formatTimestamp(diagnosis.at)}.`;
         case 'aborted': {
             const tail = diagnosis.reason !== undefined ? ` — ${diagnosis.reason}` : '';
-            return `${logSymbols.info} ${pc.dim('aborted')} at ${diagnosis.at}${tail}.`;
+            return `${logSymbols.info} ${styleText('dim', 'aborted')} at ${formatTimestamp(diagnosis.at)}${tail}.`;
         }
         case 'stuck':
-            return `${logSymbols.warning} ${pc.yellow('STUCK')} — ${causeDetail(diagnosis.cause).headline}`;
+            return `${logSymbols.warning} ${styleText('yellow', 'STUCK')} — ${causeDetail(diagnosis.cause).headline}`;
     }
 }
 /**
@@ -200,12 +193,13 @@ export function renderDiagnosis(diagnosis, input, remediations) {
     }
     if (diagnosis.state === 'stuck') {
         const detail = causeDetail(diagnosis.cause);
-        lines.push('', "why it's stuck:", ...detail.why);
+        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 (remediations.length > 0) {
-            lines.push('', 'suggested fix:', ...remediationLines(remediations));
+        if (runnable.length > 0) {
+            lines.push('', sectionHeader('Suggested fix'), ...remediationLines(runnable));
         }
     }
     return lines;
@@ -256,11 +250,7 @@ export default class Diagnose extends Command {
             }, null, 2));
             return;
         }
-        this.log(boxen(instanceHeader(evaluation.instance), {
-            padding: 1,
-            borderStyle: 'round',
-            title: 'diagnose',
-        }));
+        this.log(instanceHeader(evaluation.instance));
         this.log('');
         for (const line of renderDiagnosis(diagnosis, input, remediations)) {
             this.log(line);

package/dist/commands/fire-action.js

@@ -1,9 +1,8 @@
+import { styleText } from 'node:util';
 import { Args, Command, Flags } from '@oclif/core';
 import { workflow, } from '@sanity/workflow-engine';
-import boxen from 'boxen';
 import logSymbols from 'log-symbols';
 import ora from 'ora';
-import pc from 'picocolors';
 import { loadClient } from "../lib/client.js";
 import { loadWorkflowConfig } from "../lib/config.js";
 import { fail, failOnThrow } from "../lib/fail.js";
@@ -61,14 +60,16 @@ function paramLabel(p) {
     return `${p.name}${p.required === true ? '' : '?'}:${p.type}`;
 }
 function actionLines(a) {
-    const mark = a.allowed ? pc.green(logSymbols.success) : pc.red(logSymbols.error);
-    const title = a.title !== undefined ? pc.dim(`  (${a.title})`) : '';
-    const lines = [`  ${mark} ${a.task} → ${a.action}${title} ${pc.dim(`[task ${a.taskStatus}]`)}`];
+    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}]`)}`,
+    ];
     if (a.params.length > 0) {
-        lines.push(pc.dim(`      params: ${a.params.map(paramLabel).join(', ')}`));
+        lines.push(styleText('dim', `      params: ${a.params.map(paramLabel).join(', ')}`));
     }
     if (!a.allowed && a.disabledReason !== undefined) {
-        lines.push(pc.dim(`      disabled: ${reasonText(a.disabledReason)}`));
+        lines.push(styleText('dim', `      disabled: ${reasonText(a.disabledReason)}`));
     }
     return lines;
 }
@@ -82,11 +83,11 @@ export function renderAvailableActions(actions, stage, instanceId) {
     if (actions.length === 0) {
         return [`No actions on the tasks of the current stage ('${stage}').`];
     }
-    const lines = [pc.bold(`actions on stage '${stage}':`), ''];
+    const lines = [styleText('bold', `Actions on stage '${stage}':`), ''];
     for (const a of actions) {
         lines.push(...actionLines(a));
     }
-    lines.push('', pc.dim('fire one with:'), pc.dim(`  fire-action ${instanceId} --task <task> --action <action>`));
+    lines.push('', styleText('dim', 'Fire one with:'), styleText('dim', `  fire-action ${instanceId} --task <task> --action <action>`));
     return lines;
 }
 /** The `--json` payload for a fired action — the structured counterpart of
@@ -108,7 +109,7 @@ export function fireResultJson(result, ids) {
  * fire.
  */
 export function fireActionReport(result, task, action) {
-    const stage = pc.bold(result.instance.currentStage);
+    const stage = styleText('bold', result.instance.currentStage);
     if (!result.fired) {
         return {
             fired: false,
@@ -119,7 +120,7 @@ export function fireActionReport(result, task, action) {
     const tail = result.cascaded > 0 ? `, then cascaded ${result.cascaded} auto-transition(s)` : '';
     return {
         fired: true,
-        message: `Fired ${pc.bold(action)} on ${pc.bold(task)} — now at ${stage}${tail}`,
+        message: `Fired ${styleText('bold', action)} on ${styleText('bold', task)} — now at ${stage}${tail}`,
         opsLines: opsAppliedLines(result.ranOps),
     };
 }
@@ -198,11 +199,7 @@ export default class FireAction extends Command {
             this.log(JSON.stringify({ instanceId, stage, actions }, null, 2));
             return;
         }
-        this.log(boxen(instanceHeader(evaluation.instance), {
-            padding: 1,
-            borderStyle: 'round',
-            title: 'fire-action',
-        }));
+        this.log(instanceHeader(evaluation.instance));
         this.log('');
         for (const line of renderAvailableActions(actions, stage, instanceId)) {
             this.log(line);

package/dist/commands/list.d.ts

@@ -2,34 +2,38 @@ import { Command } from '@oclif/core';
 interface InstanceRow {
     _id: string;
     definition: string;
+    tag: string;
     currentStage: string;
-    startedAt: string;
     completedAt?: string;
     abortedAt?: string;
-    failedTaskCount: number;
+    lastChangedAt: string;
 }
+type InstanceStatus = 'aborted' | 'completed' | 'in-flight';
 interface ListFlags {
     'in-flight': boolean;
     failed: boolean;
     'workflow-id'?: string | undefined;
+    tag?: string | undefined;
     limit: number;
 }
 /**
  * Build the GROQ query + params for `list` from its flags. Pure so the
- * filter combinations can be asserted without a live dataset.
+ * filter combinations can be asserted without a live dataset. `--tag` is an
+ * optional filter: omit it and the listing spans every partition.
  */
 export declare function buildListQuery(flags: ListFlags): {
     groq: string;
     params: Record<string, unknown>;
 };
-/** Map a queried instance to its display row (derives the status column). */
+/** 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 declare function instanceRow(r: InstanceRow): {
     _id: string;
     definition: string;
+    tag: string;
     currentStage: string;
-    startedAt: string;
-    status: 'aborted' | 'completed' | 'in-flight';
-    failedTaskCount: number;
+    status: InstanceStatus;
+    lastChangedAt: string;
 };
 export default class List extends Command {
     static description: string;
@@ -38,8 +42,8 @@ export default class List extends Command {
         '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>;
-        subject: 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>;
     };
     run(): Promise<void>;
 }

package/dist/commands/list.js

@@ -1,11 +1,15 @@
+import { styleText } from 'node:util';
 import { Command, Flags } from '@oclif/core';
-import { WORKFLOW_INSTANCE_TYPE } from '@sanity/workflow-engine';
+import { WORKFLOW_INSTANCE_TYPE, tagScopeFilter } from '@sanity/workflow-engine';
 import { Table } from 'console-table-printer';
 import logSymbols from 'log-symbols';
 import { loadClient } from "../lib/client.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.
+ * filter combinations can be asserted without a live dataset. `--tag` is an
+ * optional filter: omit it and the listing spans every partition.
  */
 export function buildListQuery(flags) {
     const filters = [`_type == "${WORKFLOW_INSTANCE_TYPE}"`];
@@ -16,18 +20,22 @@ export function buildListQuery(flags) {
     // Cheap approximation of --failed: any task in any stage with status "failed".
     if (flags.failed)
         filters.push('count(stages[].tasks[status == "failed"]) > 0');
-    const groq = `*[${filters.join(' && ')}] | order(startedAt desc) [0...$limit]{
+    if (flags.tag)
+        filters.push(tagScopeFilter());
+    const groq = `*[${filters.join(' && ')}] | order(lastChangedAt desc) [0...$limit]{
       _id,
       definition,
+      tag,
       currentStage,
-      startedAt,
       completedAt,
       abortedAt,
-      "failedTaskCount": count(stages[].tasks[status == "failed"])
+      lastChangedAt
     }`;
     const params = { limit: flags.limit };
     if (flags['workflow-id'])
         params['definition'] = flags['workflow-id'];
+    if (flags.tag)
+        params['tag'] = flags.tag;
     return { groq, params };
 }
 /** Aborted instances also carry `completedAt`, so check `abortedAt` first. */
@@ -38,25 +46,33 @@ function deriveStatus(r) {
         return 'completed';
     return 'in-flight';
 }
-/** Map a queried instance to its display row (derives the status column). */
+/** 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,
-        startedAt: r.startedAt,
         status: deriveStatus(r),
-        failedTaskCount: r.failedTaskCount,
+        lastChangedAt: r.lastChangedAt,
     };
 }
+const STATUS_COLOR = {
+    completed: 'green',
+    aborted: 'dim',
+    'in-flight': 'cyan',
+};
 export default class List extends Command {
     static description = 'List workflow instances in the configured dataset.';
     static examples = [
         '<%= config.bin %> list',
         '<%= config.bin %> list --in-flight',
         '<%= config.bin %> list --workflow-id productLaunch',
+        '<%= config.bin %> list --tag prod',
     ];
     static flags = {
+        ...tagFlags,
         'in-flight': Flags.boolean({
             description: 'Only instances that have not completed.',
             default: false,
@@ -68,9 +84,6 @@ export default class List extends Command {
         'workflow-id': Flags.string({
             description: 'Filter by workflow definition name.',
         }),
-        subject: Flags.string({
-            description: 'Filter by subject document id. (not yet implemented)',
-        }),
         limit: Flags.integer({
             description: 'Maximum rows to return.',
             default: 50,
@@ -78,9 +91,6 @@ export default class List extends Command {
     };
     async run() {
         const { flags } = await this.parse(List);
-        if (flags.subject) {
-            this.warn('--subject is parsed but not yet implemented; ignoring.');
-        }
         const { groq, params } = buildListQuery(flags);
         const client = loadClient();
         const rows = await client.fetch(groq, params);
@@ -90,16 +100,24 @@ export default class List extends Command {
         }
         const table = new Table({
             columns: [
-                { name: '_id', title: 'instance', alignment: 'left' },
-                { name: 'definition', title: 'workflow', alignment: 'left' },
-                { name: 'currentStage', title: 'stage', alignment: 'left' },
-                { name: 'startedAt', title: 'started', alignment: 'left' },
-                { name: 'status', title: 'status', alignment: 'left' },
-                { name: 'failedTaskCount', title: 'failed', alignment: 'right' },
+                { 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' },
             ],
         });
         for (const r of rows) {
-            table.addRow(instanceRow(r));
+            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),
+            });
         }
         table.printTable();
     }

package/dist/commands/move-stage.js

@@ -1,7 +1,7 @@
+import { styleText } from 'node:util';
 import { Args, Command, Flags } from '@oclif/core';
 import { workflow } from '@sanity/workflow-engine';
 import ora from 'ora';
-import pc from 'picocolors';
 import { loadClient } from "../lib/client.js";
 import { loadWorkflowConfig } from "../lib/config.js";
 import { fail } from "../lib/fail.js";
@@ -60,7 +60,7 @@ export function buildSetStageArgs(config, instanceId, targetStage, reason) {
  * without driving a real transition.
  */
 export function moveStageReport(result, to) {
-    const stage = pc.bold(result.instance.currentStage);
+    const stage = styleText('bold', result.instance.currentStage);
     if (!result.fired) {
         return {
             fired: false,

package/dist/commands/show.d.ts

@@ -11,7 +11,8 @@ export default class Show extends Command {
     };
     run(): Promise<void>;
 }
-/** The boxed summary block at the top of `show` output. */
+/** The summary block at the top of `show` (and reused by `diagnose` /
+ *  `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

package/dist/commands/show.js

@@ -1,8 +1,9 @@
+import { styleText } from 'node:util';
 import { Args, Command, Flags } from '@oclif/core';
 import { abortReason } from '@sanity/workflow-engine';
-import boxen from 'boxen';
 import logSymbols from 'log-symbols';
 import { loadClient } from "../lib/client.js";
+import { formatKeyValue, formatTimestamp, sectionHeader, taskIcon } from "../lib/ui.js";
 export default class Show extends Command {
     static description = 'Show the state, tasks, and effects of a workflow instance.';
     static examples = [
@@ -30,7 +31,7 @@ export default class Show extends Command {
         if (!instance) {
             this.error(`${logSymbols.error} no instance with id "${args.instanceId}"`, { exit: 1 });
         }
-        this.log(boxen(instanceHeader(instance), { padding: 1, borderStyle: 'round', title: 'instance' }));
+        this.log(instanceHeader(instance));
         this.log('');
         for (const line of describeInstance(instance, {
             includeHistory: flags.include.includes('history'),
@@ -39,21 +40,32 @@ export default class Show extends Command {
         }
     }
 }
-/** The boxed summary block at the top of `show` output. */
+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. */
 export function instanceHeader(instance) {
-    const reason = abortReason(instance);
-    const abortedLine = instance.abortedAt
-        ? [`aborted:     ${instance.abortedAt}${reason ? ` — ${reason}` : ''}`]
-        : [];
-    return [
-        `instance:    ${instance._id}`,
-        `workflow:    ${instance.definition} v${instance.pinnedVersion}`,
-        `stage:       ${instance.currentStage}`,
-        `started:     ${instance.startedAt}`,
-        `completed:   ${instance.completedAt ?? '—'}`,
-        ...abortedLine,
-        `tag:         ${instance.tag}`,
-    ].join('\n');
+    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 }),
+    ];
+    // 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) {
+        const reason = abortReason(instance);
+        const tail = reason ? ` — ${reason}` : '';
+        const value = styleText('yellow', `${formatTimestamp(instance.abortedAt)}${tail}`);
+        rows.push(formatKeyValue('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('Tag', instance.tag, { padTo: HEADER_PAD }));
+    return [title, ...rows].join('\n');
 }
 /**
  * The per-instance body lines: every stage with its tasks, any pending
@@ -61,24 +73,26 @@ export function instanceHeader(instance) {
  * without driving the oclif command.
  */
 export function describeInstance(instance, options) {
-    const lines = ['stages:'];
+    const lines = [sectionHeader('Stages')];
     for (const stage of instance.stages) {
-        const exited = stage.exitedAt ? ` (exited ${stage.exitedAt})` : ' (current)';
-        lines.push(`  • ${stage.name}${exited}`);
+        const marker = stage.exitedAt
+            ? styleText('dim', ` (exited ${formatTimestamp(stage.exitedAt)})`)
+            : styleText('cyan', ' (current)');
+        lines.push(`  • ${stage.name}${marker}`);
         for (const task of stage.tasks) {
-            lines.push(`      - ${task.name}  [${task.status}]`);
+            lines.push(`      ${taskIcon[task.status]} ${task.name}  ${styleText('dim', `[${task.status}]`)}`);
         }
     }
     if (instance.pendingEffects.length > 0) {
-        lines.push('', 'pending effects:');
+        lines.push('', sectionHeader('Pending effects'));
         for (const eff of instance.pendingEffects) {
-            lines.push(`  • ${eff.name}  (key=${eff._key})`);
+            lines.push(`  • ${eff.name}  ${styleText('dim', `(key=${eff._key})`)}`);
         }
     }
     if (options.includeHistory) {
-        lines.push('', 'history:');
+        lines.push('', sectionHeader('History'));
         for (const entry of instance.history) {
-            lines.push(`  • [${entry.at}] ${entry._type}`);
+            lines.push(`  ${styleText('dim', `[${formatTimestamp(entry.at)}]`)} ${entry._type}`);
         }
     }
     return lines;

package/dist/commands/tail.js

@@ -1,8 +1,9 @@
+import { styleText } from 'node:util';
 import { Args, Command } from '@oclif/core';
 import logSymbols from 'log-symbols';
-import pc from 'picocolors';
 import { buildClient, loadClient } from "../lib/client.js";
 import { fail } from "../lib/fail.js";
+import { formatTimestamp } from "../lib/ui.js";
 export default class Tail extends Command {
     static description = 'Stream new history entries on a workflow instance as they land in the dataset.';
     static examples = ['<%= config.bin %> tail wf-instance.abc123'];
@@ -19,8 +20,8 @@ export default class Tail extends Command {
         if (!initial) {
             fail(`No instance with id "${args.instanceId}"`);
         }
-        this.log(pc.dim(`tailing ${pc.bold(args.instanceId)} (${initial.definition} v${initial.pinnedVersion}, ${initial.history.length} prior entries, currently in ${initial.currentStage})`));
-        this.log(pc.dim('Ctrl+C to stop'));
+        this.log(styleText('dim', `tailing ${styleText('bold', args.instanceId)} (${initial.definition} v${initial.pinnedVersion}, ${initial.history.length} prior entries, currently in ${initial.currentStage})`));
+        this.log(styleText('dim', 'Ctrl+C to stop'));
         this.log('');
         // Track the high-water mark so we only print history entries that
         // landed after we started tailing. Listening with `includeResult:
@@ -36,7 +37,7 @@ export default class Tail extends Command {
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
-                    process.stderr.write(`${pc.red(`${logSymbols.error} fetch failed:`)} ${message}\n`);
+                    process.stderr.write(`${styleText('red', `${logSymbols.error} fetch failed:`)} ${message}\n`);
                 }
             },
             error: (err) => {
@@ -46,7 +47,7 @@ export default class Tail extends Command {
         });
         const shutdown = () => {
             subscription.unsubscribe();
-            process.stderr.write(`\n${pc.dim(`${logSymbols.info} stopped`)}\n`);
+            process.stderr.write(`\n${styleText('dim', `${logSymbols.info} stopped`)}\n`);
             process.exit(0);
         };
         process.on('SIGINT', shutdown);
@@ -66,7 +67,7 @@ export default class Tail extends Command {
             return seen;
         const newEntries = next.history.slice(seen);
         for (const entry of newEntries) {
-            this.log(`${pc.dim(`[${entry.at}]`)} ${pc.cyan(entry._type)}`);
+            this.log(`${styleText('dim', `[${formatTimestamp(entry.at)}]`)} ${styleText('cyan', entry._type)}`);
         }
         return next.history.length;
     }

package/dist/lib/diff.js

@@ -1,15 +1,16 @@
+import { styleText } from 'node:util';
 import { diffJson } from 'diff';
 import logSymbols from 'log-symbols';
-import pc from 'picocolors';
+import { sectionHeader } from "./ui.js";
 /** One summary line per diff entry, tagged create / update / unchanged. */
 export function summaryLines(entries) {
     const tags = {
-        create: pc.green('+ create   '),
-        update: pc.yellow('~ update   '),
-        unchanged: pc.dim('  unchanged'),
+        create: styleText('green', '+ create   '),
+        update: styleText('yellow', '~ update   '),
+        unchanged: styleText('dim', '  unchanged'),
     };
     return entries.map((e) => {
-        return `  ${tags[e.status]} ${e.name} v${e.version}  ${pc.dim(`(${e.docId})`)}`;
+        return `  ${tags[e.status]} ${e.name} v${e.version}  ${styleText('dim', `(${e.docId})`)}`;
     });
 }
 /** Render a JSON diff of `oldObj` → `newObj` as `+`/`-`/context lines. */
@@ -23,18 +24,18 @@ export function diffLines(oldObj, newObj) {
             chunkLines.pop();
         for (const line of chunkLines) {
             if (chunk.added)
-                out.push(pc.green(`+ ${line}`));
+                out.push(styleText('green', `+ ${line}`));
             else if (chunk.removed)
-                out.push(pc.red(`- ${line}`));
+                out.push(styleText('red', `- ${line}`));
             else
-                out.push(pc.dim(`  ${line}`));
+                out.push(styleText('dim', `  ${line}`));
         }
     }
     return out;
 }
 /** The full diff report: the summary block plus a per-change diff. */
 export function diffReport(entries) {
-    const lines = ['', pc.bold('Summary'), ...summaryLines(entries)];
+    const lines = ['', sectionHeader('Summary'), ...summaryLines(entries)];
     const changes = entries.filter((e) => e.status !== 'unchanged');
     if (changes.length === 0) {
         lines.push('', `${logSymbols.success} no changes — running deploy would be a no-op`);
@@ -43,7 +44,7 @@ export function diffReport(entries) {
     for (const e of changes) {
         // For net-new docs, existing is undefined — render the whole expected
         // doc as added lines so the operator sees what would land.
-        lines.push('', pc.bold(`── ${e.name} v${e.version} ──`), ...diffLines(e.existing ?? {}, e.expected));
+        lines.push('', styleText('bold', `── ${e.name} v${e.version} ──`), ...diffLines(e.existing ?? {}, e.expected));
     }
     return lines;
 }

package/dist/lib/fail.js

@@ -1,5 +1,5 @@
+import { styleText } from 'node:util';
 import logSymbols from 'log-symbols';
-import pc from 'picocolors';
 /**
  * Render a user-facing error and exit non-zero. Writes straight to
  * stderr — no oclif framing, no Node stack — so expected failures
@@ -9,7 +9,7 @@ import pc from 'picocolors';
  * error propagate so the stack is visible for debugging.
  */
 export function fail(headline, detail) {
-    process.stderr.write(`${pc.red(`${logSymbols.error} ${headline}`)}\n`);
+    process.stderr.write(`${styleText('red', `${logSymbols.error} ${headline}`)}\n`);
     if (detail !== undefined && detail !== '') {
         for (const line of detail.split('\n')) {
             process.stderr.write(`  ${line}\n`);

package/dist/lib/ops-report.js

@@ -1,5 +1,5 @@
+import { styleText } from 'node:util';
 import logSymbols from 'log-symbols';
-import pc from 'picocolors';
 /**
  * The "ops applied" block shared by write-verb reports (move-stage,
  * fire-action): a blank separator, a header, and one line per primitive
@@ -7,10 +7,10 @@ import pc from 'picocolors';
  */
 export function opsAppliedLines(ranOps) {
     const details = (ranOps ?? []).map((op) => {
-        const target = op.target ? pc.dim(` → ${op.target.scope}.${op.target.state}`) : '';
+        const target = op.target ? styleText('dim', ` → ${op.target.scope}.${op.target.state}`) : '';
         return `  ${logSymbols.info} ${op.opType}${target}`;
     });
-    return details.length > 0 ? ['', pc.dim('ops applied:'), ...details] : [];
+    return details.length > 0 ? ['', styleText('dim', 'ops applied:'), ...details] : [];
 }
 /**
  * Emit a write-verb report through its spinner: warn and bail when the

package/dist/lib/ui.d.ts

@@ -0,0 +1,24 @@
+import type { TaskStatus } 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.
+ */
+export declare function sectionHeader(title: string): string;
+/**
+ * A `  key:   value` detail row — a dim, padded key then the value. Mirrors
+ * 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?: {
+    indent?: number;
+    padTo?: number;
+}): string;
+/** Status glyph per task 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>;
+/** 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;
+/** An engine ISO-8601 timestamp as a relative `… ago` — the Sanity CLI's
+ *  job-list format (see `datasets/copy`). For scannable overview tables. */
+export declare function formatAge(iso: string): string;

package/dist/lib/ui.js

@@ -0,0 +1,55 @@
+import { styleText } from 'node:util';
+import { formatDistanceToNow } from 'date-fns/formatDistanceToNow';
+import { lightFormat } from 'date-fns/lightFormat';
+import { parseISO } from 'date-fns/parseISO';
+import logSymbols from 'log-symbols';
+/**
+ * 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.
+ */
+export function sectionHeader(title) {
+    return styleText('bold', `${title}:`);
+}
+/**
+ * A `  key:   value` detail row — a dim, padded key then the value. Mirrors
+ * 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;
+    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 ✖),
+ *  so those need no extra wrap; the rest carry their own state color. */
+export const taskIcon = {
+    done: logSymbols.success,
+    active: styleText('cyan', '●'),
+    pending: styleText('dim', '○'),
+    failed: logSymbols.error,
+    skipped: styleText('dim', '⊘'),
+};
+/** Parse an engine ISO-8601 timestamp, or `undefined` when it's missing or
+ *  unparseable. The engine writes valid ISO, but the lake is the only
+ *  enforcement boundary — a legacy or raw-client-written doc can carry a bad
+ *  or absent timestamp, and `parseISO`/`lightFormat` throw on those. Callers
+ *  fall back to the raw value so one bad field never crashes a whole command. */
+function parseTimestamp(iso) {
+    if (!iso)
+        return undefined;
+    const date = parseISO(iso);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+/** 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 function formatTimestamp(iso) {
+    const date = parseTimestamp(iso);
+    return date ? lightFormat(date, 'yyyy-MM-dd HH:mm:ss') : iso;
+}
+/** An engine ISO-8601 timestamp as a relative `… ago` — the Sanity CLI's
+ *  job-list format (see `datasets/copy`). For scannable overview tables. */
+export function formatAge(iso) {
+    const date = parseTimestamp(iso);
+    return date ? `${formatDistanceToNow(date)} ago` : iso;
+}

package/oclif.manifest.json

@@ -233,9 +233,17 @@
       "examples": [
         "<%= config.bin %> list",
         "<%= config.bin %> list --in-flight",
-        "<%= config.bin %> list --workflow-id productLaunch"
+        "<%= config.bin %> list --workflow-id productLaunch",
+        "<%= config.bin %> list --tag prod"
       ],
       "flags": {
+        "tag": {
+          "description": "Workflow environment tag (e.g. prod, test). Overrides WORKFLOW_TAG.",
+          "name": "tag",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "in-flight": {
           "description": "Only instances that have not completed.",
           "name": "in-flight",
@@ -255,13 +263,6 @@
           "multiple": false,
           "type": "option"
         },
-        "subject": {
-          "description": "Filter by subject document id. (not yet implemented)",
-          "name": "subject",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
         "limit": {
           "description": "Maximum rows to return.",
           "name": "limit",
@@ -680,5 +681,5 @@
       ]
     }
   },
-  "version": "0.5.2"
+  "version": "0.6.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/workflow-cli",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Command-line tool for deploying, inspecting, and administering Sanity workflow definitions and instances.",
   "keywords": [
     "cli",
@@ -49,19 +49,19 @@
     "@sanity/client": "^7.22.1",
     "boxen": "^8.0.1",
     "console-table-printer": "^2.16.0",
+    "date-fns": "^4.4.0",
     "diff": "^9.0.0",
     "log-symbols": "^7.0.1",
     "ora": "^9.4.0",
-    "picocolors": "^1.1.1",
-    "@sanity/workflow-engine": "0.7.0"
+    "@sanity/workflow-engine": "0.8.0"
   },
   "devDependencies": {
     "@types/diff": "^8.0.0",
     "@types/node": "^24.12.4",
     "oclif": "^4.23.16",
     "vitest": "^4.1.8",
-    "@sanity/workflow-engine-test": "0.4.1",
-    "@sanity/workflow-examples": "0.1.3"
+    "@sanity/workflow-engine-test": "0.4.2",
+    "@sanity/workflow-examples": "0.1.4"
   },
   "oclif": {
     "bin": "sanity-workflows",
@@ -81,7 +81,7 @@
     }
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20.12"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",