@skrr-ai/cli 0.1.109 → 0.1.111

package/dist/commands/tasks/list.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.agentSessionOpenDefault = agentSessionOpenDefault;
 exports.emptyTasksMessage = emptyTasksMessage;
+exports.externalKeyPrefixWarnings = externalKeyPrefixWarnings;
 exports.nextActionText = nextActionText;
 exports.nextColumnWidth = nextColumnWidth;
 exports.taskRef = taskRef;
+exports.taskExecution = taskExecution;
+exports.taskPageSummary = taskPageSummary;
+exports.taskExecutionText = taskExecutionText;
 exports.buildListParams = buildListParams;
 exports.statusFilterWarnings = statusFilterWarnings;
 const core_1 = require("@oclif/core");
@@ -151,6 +155,19 @@ function emptyTasksMessage(flags, bin = 'skrr') {
     }
     return lines.join('\n');
 }
+/** An empty filtered page is evidence about this query, not an empty Space. */
+function externalKeyPrefixWarnings(flags, rowCount) {
+    const prefix = flags['external-key-prefix'];
+    if (typeof prefix !== 'string' || rowCount !== 0)
+        return [];
+    return [
+        {
+            code: 'EXTERNAL_KEY_PREFIX_MATCHED_NOTHING',
+            value: { prefix, space: flags.space ?? null },
+            hint: `No tasks matched --external-key-prefix ${JSON.stringify(prefix)}${flags.space ? ` in space ${String(flags.space)}` : ''}. Check the prefix or run the same command without --external-key-prefix.`,
+        },
+    ];
+}
 /**
  * `--status` is repeatable, so the flag value is a list; callers that predate
  * that and tests that pass a bare string both normalize through here.
@@ -217,6 +234,56 @@ function nextColumnWidth(rows) {
 function taskRef(t) {
     return String(t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-'));
 }
+/** Evidence about managed execution only; unmanaged work is outside this projection. */
+function taskExecution(t) {
+    const actionability = t.actionability;
+    if (actionability?.state === 'terminal')
+        return { state: 'terminal' };
+    if (actionability?.execution)
+        return { ...actionability.execution };
+    // Older servers cannot distinguish an active Run from a retained checkout. Do not infer
+    // liveness from their `running` actionability, assigned agents, or workflow status.
+    if (!actionability || actionability.state === 'running')
+        return { state: 'unknown' };
+    return { state: 'not_observed' };
+}
+function taskPageSummary(items, hasMore) {
+    const countBy = (values) => values.reduce((out, value) => {
+        out[value] = (out[value] ?? 0) + 1;
+        return out;
+    }, {});
+    const assignment = (t) => {
+        if ((Array.isArray(t.assigneeAgentIds) && t.assigneeAgentIds.length > 0) ||
+            (Array.isArray(t.assigneeUserIds) && t.assigneeUserIds.length > 0))
+            return 'assigned';
+        return Array.isArray(t.assigneeAgentIds) && Array.isArray(t.assigneeUserIds)
+            ? 'unassigned' : 'unknown';
+    };
+    return {
+        scope: 'fetched_page',
+        taskCount: items.length,
+        has_more: hasMore,
+        workflow: countBy(items.map((t) => String(t.statusType ?? 'unknown'))),
+        assignment: {
+            assigned: items.filter((t) => assignment(t) === 'assigned').length,
+            unassigned: items.filter((t) => assignment(t) === 'unassigned').length,
+            unknown: items.filter((t) => assignment(t) === 'unknown').length,
+        },
+        readiness: countBy(items.map((t) => String(t.actionability?.reasonCode ?? 'unknown'))),
+        execution: countBy(items.map((t) => String(taskExecution(t).state))),
+        measurement: 'Managed execution evidence at read time; unmanaged work is not measured.',
+    };
+}
+function taskExecutionText(t) {
+    const execution = taskExecution(t);
+    switch (execution.state) {
+        case 'run_active': return `Run ${String(execution.runStatus ?? 'active')}${execution.agentId ? ` (${String(execution.agentId)})` : ''}`;
+        case 'checkout_held': return 'Checkout held; Run unverified';
+        case 'terminal': return 'Terminal';
+        case 'not_observed': return 'No active Run observed';
+        default: return 'Unknown';
+    }
+}
 /**
  * The task-list request bag is shared with import/export so every CLI list
  * surface serializes the same server-side filters. Keep user-id resolution in
@@ -501,10 +568,13 @@ class TasksList extends base_command_1.BaseCommand {
         view: core_1.Flags.string({
             description: 'Only tasks a saved Task View selects (task_view_…; see `views list`). Combines with other filters',
         }),
-        limit: core_1.Flags.integer({ description: 'Max results', default: 50 }),
+        limit: core_1.Flags.integer({
+            description: 'Results per page (default 50). Follow next_cursor with --cursor for remaining pages.',
+            default: 50,
+        }),
         cursor: core_1.Flags.string({ description: 'Pagination cursor from a previous page' }),
         all: core_1.Flags.boolean({
-            description: 'Include closed tasks even inside an agent session (where --json defaults to open work and reports filter_applied)',
+            description: 'Include closed tasks inside an agent session. This changes status filtering only; it does not fetch all pages. Use --cursor to continue.',
         }),
         ...list_output_1.listOutputFlags,
         strict: core_1.Flags.boolean({
@@ -588,14 +658,18 @@ class TasksList extends base_command_1.BaseCommand {
             Array.isArray(response.data)) {
             response = {
                 ...response,
-                data: (0, data_provider_1.rankEconomicItems)(response.data),
+                // Each row carries the `economicsRank` it was sorted by, so `--json` shows the same SCORE
+                // as the table, computed once in the shared ranking (OSK-16476).
+                data: (0, data_provider_1.annotateEconomicRank)(response.data),
                 rank_applied: { key: 'economics', scope: 'fetched_page' },
             };
         }
         const list = response;
+        const rowCount = Array.isArray(list?.data) ? list.data.length : 0;
+        const prefixWarnings = calendarRange ? [] : externalKeyPrefixWarnings(flags, rowCount);
         const statusWarnings = calendarRange
             ? []
-            : statusFilterWarnings(flags, Array.isArray(list?.data) ? list.data.length : 0);
+            : [...statusFilterWarnings(flags, rowCount), ...prefixWarnings];
         if (flags.strict && statusWarnings.some((w) => w.code === 'STATUS_NOT_BUILTIN')) {
             const bad = statusWarnings.find((w) => w.code === 'STATUS_NOT_BUILTIN');
             this.failWithCliError({
@@ -616,10 +690,12 @@ class TasksList extends base_command_1.BaseCommand {
             const enriched = list && Array.isArray(list.data)
                 ? {
                     ...list,
+                    ...(!calendarRange ? { summary: taskPageSummary(list.data, Boolean(list.has_more ?? list.next_cursor)) } : {}),
                     data: list.data.map((t) => ({
                         ...t,
                         ref: taskRef(t),
                         nextAction: nextActionText(t),
+                        ...(!calendarRange ? { execution: taskExecution(t) } : {}),
                     })),
                 }
                 : response;
@@ -633,7 +709,19 @@ class TasksList extends base_command_1.BaseCommand {
                     compact: flags.compact,
                     requestedLimit: flags.limit,
                     warnings: statusWarnings,
-                    ...(filterApplied ? { filterApplied } : {}),
+                    ...(filterApplied || flags['external-key-prefix']
+                        ? {
+                            filterApplied: {
+                                ...filterApplied,
+                                ...(flags['external-key-prefix']
+                                    ? {
+                                        externalKeyPrefix: flags['external-key-prefix'],
+                                        spaceId: flags.space ?? null,
+                                    }
+                                    : {}),
+                            },
+                        }
+                        : {}),
                 });
             this.printList(out, Boolean(flags.ndjson));
             return;
@@ -666,6 +754,8 @@ class TasksList extends base_command_1.BaseCommand {
         const items = r?.data ?? [];
         if (items.length === 0) {
             this.log(emptyTasksMessage(flags, this.config.bin));
+            for (const line of (0, list_output_1.warningLines)(prefixWarnings))
+                this.log(line);
             return;
         }
         const rows = items.map((t) => {
@@ -686,6 +776,7 @@ class TasksList extends base_command_1.BaseCommand {
                 priority: String(t.priority ?? '-'),
                 estimate: t.estimate === null || t.estimate === undefined ? '-' : String(t.estimate),
                 assignees,
+                execution: taskExecutionText(t),
                 next: nextActionText(t),
                 match: String(t._matchField ?? '-'),
                 savings: economics?.savings
@@ -693,7 +784,9 @@ class TasksList extends base_command_1.BaseCommand {
                     : 'Unknown',
                 effort: economics?.effortHours !== undefined ? `${economics.effortHours}h` : 'Unknown',
                 risk: economics?.risk ?? 'Unknown',
-                score: (0, task_economics_1.economicsScoreText)(economics),
+                score: t.economicsRank
+                    ? (0, task_economics_1.scoreText)(t.economicsRank.score)
+                    : (0, task_economics_1.economicsScoreText)(economics),
                 basis: economics?.basis && Object.prototype.hasOwnProperty.call(basis, economics.basis)
                     ? basis[economics.basis]
                     : 'Unknown',
@@ -715,6 +808,7 @@ class TasksList extends base_command_1.BaseCommand {
                 : []),
             { key: 'estimate', header: 'ESTIMATE' },
             { key: 'assignees', header: 'ASSIGNEES' },
+            { key: 'execution', header: 'EXECUTION', maxWidth: 58 },
             // Bounded: the reason is a sentence, and an unbounded column wraps the
             // table into unreadability on a narrow terminal.
             { key: 'next', header: 'NEXT', maxWidth: nextColumnWidth(rows) },
@@ -723,6 +817,9 @@ class TasksList extends base_command_1.BaseCommand {
             ...(flags.q ? [{ key: 'match', header: 'MATCH' }] : []),
             { key: 'id', header: 'ID' },
         ], (line) => this.log(line));
+        const summary = taskPageSummary(items, Boolean(r?.has_more ?? r?.next_cursor));
+        this.log(`\nFetched page: ${items.length} tasks; ${summary.assignment.unassigned} unassigned; ${summary.execution.run_active ?? 0} active managed Runs; ${summary.execution.checkout_held ?? 0} retained checkouts; ${summary.execution.unknown ?? 0} execution unknown. ${summary.has_more ? 'More pages available.' : 'Last page.'}`);
+        this.log(summary.measurement);
         if (flags.rank)
             this.log('\nRanked only within this fetched page; estimates are claims, not measured savings.\n' +
                 'SCORE = annualized USD savings / max(effort hours, 0.5) x risk factor (low 1, medium 0.6, high 0.25); ' +

package/dist/commands/tasks/move.js

@@ -63,6 +63,7 @@ class TasksMove extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksMove);
+        this.setJsonOperation({ command: 'tasks:move', mode: 'execute' });
         let taskIdentity;
         try {
             taskIdentity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
@@ -78,7 +79,7 @@ class TasksMove extends base_command_1.BaseCommand {
             });
         }
         const taskRef = await this.resolveEntityRef('task', taskIdentity.id);
-        const projectId = (0, projects_1.resolveTaskProjectFlag)(flags.project);
+        let projectId = (0, projects_1.resolveTaskProjectFlag)(flags.project);
         if (projectId !== undefined) {
             try {
                 (0, unsupported_managed_task_write_1.refuseUnsupportedManagedTaskWrite)('Project changes', 'mcp__tasks__task_update');
@@ -96,6 +97,11 @@ class TasksMove extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
+        if (typeof projectId === 'string') {
+            const placement = { projectId };
+            await this.resolveTaskResourceReferences(placement, { taskId: taskRef });
+            projectId = placement.projectId;
+        }
         // Whether a target is blocked is a Space-specific TYPE decision. The
         // server validates and applies these optional hold details after resolving
         // the state; a client must not guess from a display name.
@@ -148,7 +154,9 @@ class TasksMove extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
-            this.log(JSON.stringify((0, web_url_1.withTaskUrl)(this.cliConfig.baseURL, updated), null, 2));
+            this.printJsonOperation((0, web_url_1.withTaskUrl)(this.cliConfig.baseURL, updated), {
+                resource: { kind: 'task', id: updated?.id }, task: { id: updated?.id },
+            });
             return;
         }
         const t = (updated ?? {});

package/dist/commands/tasks/preflight.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command';
+export default class TasksPreflight extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        skill: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/tasks/preflight.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const task_resolver_1 = require("../../lib/task-resolver");
+const task_preflight_1 = require("../../lib/task-preflight");
+class TasksPreflight extends base_command_1.BaseCommand {
+    static description = 'Inspect workflow blockers and execution prerequisites without starting work or probing a machine';
+    static args = {
+        id: core_1.Args.string({ description: 'Task ID/ref; defaults to the current Task runtime', ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output native observations, uncertainty, and CLI verification metadata as JSON' }),
+        task: core_1.Flags.string({ description: 'Task ID/ref; overrides current Task runtime context' }),
+        skill: core_1.Flags.string({ description: 'Skill ID for the existing server execution preview' }),
+    };
+    static examples = [
+        '<%= config.bin %> tasks preflight OSK-123',
+        '<%= config.bin %> tasks preflight --json',
+    ];
+    async run() {
+        this.setJsonOperation({ command: 'tasks:preflight', mode: 'verify', writeState: 'not_attempted' });
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksPreflight);
+        let identity;
+        try {
+            identity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+        }
+        catch (error) {
+            const failure = (0, task_resolver_1.taskResolutionFailure)(error);
+            this.failWithCliError({ message: failure.message, code: failure.code, exit: 2, retryable: false,
+                details: { suggestion: failure.suggestion } });
+        }
+        let taskId = await this.resolveTaskReference(identity.id);
+        // Native endpoints accept identifiers, so BaseCommand intentionally keeps
+        // OSK-123 unchanged. Correlating two diagnostic records needs the returned
+        // canonical identity; UUID/title-resolved callers keep their request count.
+        if (/^[A-Z]+-\d+$/i.test(taskId)) {
+            let task;
+            try {
+                task = await data_provider_1.dataService.getTask(taskId, { enrich: false });
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (typeof task?.id !== 'string' || !/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i.test(task.id) ||
+                (task.identifier !== undefined && (typeof task.identifier !== 'string' || task.identifier.toUpperCase() !== taskId.toUpperCase()))) {
+                this.failWithCliError({
+                    code: 'TASK_PREFLIGHT_IDENTITY_UNCONFIRMED',
+                    message: 'The server did not confirm a canonical Task identity for this reference. Inspect tasks show <task> --json before repeating preflight.',
+                    exit: 2, retryable: false,
+                });
+            }
+            taskId = task.id;
+        }
+        const report = await (0, task_preflight_1.readTaskPreflight)(taskId, {
+            workflow: () => data_provider_1.dataService.getTaskActionability(taskId),
+            execution: () => data_provider_1.dataService.previewTaskStart(taskId, flags.skill ? { skillId: flags.skill } : undefined),
+        });
+        // Only native diagnostic responses establish an identity for _cli; a
+        // requested ref is not itself a confirmed Task record.
+        const nativeId = report.workflow.status === 'observed' ? report.workflow.value.taskId
+            : report.execution.status === 'observed' ? report.execution.value.taskId : null;
+        if (flags.json)
+            this.printJsonOperation({ ok: report.summary === 'eligible_to_attempt', ...report }, {
+                resource: nativeId ? { kind: 'task', id: nativeId } : null,
+                task: nativeId ? { id: nativeId } : null,
+            });
+        else
+            for (const line of (0, task_preflight_1.taskPreflightLines)(report, this.config.bin))
+                this.log(line);
+        if (report.summary !== 'eligible_to_attempt')
+            this.exit(report.summary === 'blocked' ? 1 : 2);
+    }
+}
+exports.default = TasksPreflight;

package/dist/commands/tasks/rearm-recurrence.js

@@ -60,9 +60,28 @@ class TasksRearmRecurrence extends base_command_1.BaseCommand {
         const from = finished.identifier || finished.id || taskRef;
         const next = result.successor.identifier || result.successor.id;
         const when = result.successor.scheduledFor ? ` for ${result.successor.scheduledFor}` : '';
-        this.log(result.alreadyArmed
-            ? `The series from ${from} was already armed: next occurrence ${next}${when}. The failure marker is cleared.`
-            : `Re-armed the series from ${from}: next occurrence ${next} is scheduled${when}.`);
+        // The server's sentence IS the answer: it is derived with the JSON fields, so the two can
+        // never disagree (round 3 of OSK-15321 found them disagreeing). The fallback below is only
+        // for an older server that sends no `message`.
+        if (typeof result.message === 'string' && result.message) {
+            this.log(result.message);
+            return;
+        }
+        // Never call a successor with no schedule "armed": it will not fire (#4262 verification).
+        let line;
+        if (!result.successor.scheduledFor) {
+            line = `The next occurrence ${next} of the series from ${from} exists but has no schedule, so nothing will fire it on its own; start it by hand or give it a time with \`${this.config.bin} tasks schedule ${next} --at <ISO time>\`.`;
+        }
+        else if (result.rescheduled) {
+            line = `The next occurrence ${next} existed but had no schedule; it is now scheduled${when}. The failure marker is cleared.`;
+        }
+        else if (result.alreadyArmed) {
+            line = `The series from ${from} was already armed: next occurrence ${next}${when}. The failure marker is cleared.`;
+        }
+        else {
+            line = `Re-armed the series from ${from}: next occurrence ${next} is scheduled${when}.`;
+        }
+        this.log(line);
     }
 }
 exports.default = TasksRearmRecurrence;

package/dist/commands/tasks/resource/list.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const list_output_1 = require("../../../lib/list-output");
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
@@ -29,7 +30,7 @@ class TasksResourceList extends base_command_1.BaseCommand {
             this.handleApiError(error);
         }
         if (flags.json)
-            return this.log(JSON.stringify(result, null, 2));
+            return this.printJsonResult((0, list_output_1.listResult)(result));
         if (!result.data.length)
             return this.log('No Resources linked.');
         for (const item of result.data) {

package/dist/commands/tasks/result/submit.js

@@ -42,6 +42,7 @@ const web_url_1 = require("../../../lib/web-url");
 const api_fetch_1 = require("../../../lib/api-fetch");
 const task_closure_1 = require("../../../lib/task-closure");
 const session_task_write_1 = require("../../../lib/session-task-write");
+const task_write_attribution_1 = require("../../../lib/task-write-attribution");
 function parseJson(value, label) {
     if (!value)
         return undefined;
@@ -92,6 +93,7 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
     };
     async run() {
+        this.setJsonOperation({ command: 'tasks:result:submit', mode: 'execute' });
         this.requireAuth();
         const { args, flags } = await this.parse(TasksResultSubmit);
         const task = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.task, flagTask: flags.task });
@@ -202,8 +204,13 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
             this.handleApiError(error);
         }
         const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: task.id });
+        const attribution = (0, task_write_attribution_1.taskWriteAttribution)(result, 'submittedBy');
         if (flags.json)
-            return this.log(JSON.stringify({ ...result, url }, null, 2));
+            return this.printJsonOperation({ ...result, url, attribution }, {
+                resource: { kind: 'task_result', id: result?.result?.id },
+                task: { id: result?.result?.taskId },
+                ...(typeof result?.idempotent === 'boolean' ? { replayed: result.idempotent } : {}),
+            });
         // Say what came back, never what we hope came back.
         //
         // This line used to read "...; it is ready for review." unconditionally,
@@ -212,6 +219,8 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
         // which the call did not carry. Submitting a Result is not closing a Task;
         // the response now reports where it stands and this prints exactly that.
         this.log(`Submitted Result v${result.result.version} (${result.result.id}) for ${task.id}.`);
+        for (const line of (0, task_write_attribution_1.attributionLines)(attribution))
+            this.log(line);
         for (const line of (0, task_closure_1.closureReport)(result.closure, { closing: false }))
             this.log(line);
         if (url)

package/dist/commands/tasks/review.js

@@ -22,6 +22,7 @@ class TasksReview extends base_command_1.BaseCommand {
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
     };
     async run() {
+        this.setJsonOperation({ command: 'tasks:review', mode: 'execute' });
         this.requireAuth();
         const { args, flags } = await this.parse(TasksReview);
         const task = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.task, flagTask: flags.task });
@@ -47,7 +48,11 @@ class TasksReview extends base_command_1.BaseCommand {
             this.handleApiError(error);
         }
         if (flags.json)
-            return this.log(JSON.stringify(result, null, 2));
+            return this.printJsonOperation(result, {
+                resource: { kind: 'task_review', id: result?.review?.id },
+                task: { id: result?.review?.taskId },
+                ...(typeof result?.idempotent === 'boolean' ? { replayed: result.idempotent } : {}),
+            });
         this.log(`Recorded Review: ${flags.decision} for Result ${flags['result-id']}.`);
     }
 }

package/dist/commands/tasks/revisions.d.ts

@@ -1,4 +1,6 @@
 import { BaseCommand } from '../../base-command';
+/** " (via CLI credential)" when the revision recorded its credential channel. */
+export declare function revisionChannelSuffix(rev: Record<string, unknown>): string;
 export default class TasksRevisions extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/tasks/revisions.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.revisionChannelSuffix = revisionChannelSuffix;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const format_1 = require("../../lib/format");
+/** " (via CLI credential)" when the revision recorded its credential channel. */
+function revisionChannelSuffix(rev) {
+    const via = rev.metadata?.via;
+    return (0, data_provider_1.principalChannelSuffix)({ kind: 'human', via });
+}
 class TasksRevisions extends base_command_1.BaseCommand {
     static description = 'List revisions for a task';
     static examples = [
@@ -39,7 +45,8 @@ class TasksRevisions extends base_command_1.BaseCommand {
         const rows = items.map((rev) => ({
             version: String(rev.revisionNumber ?? '-'),
             changeType: String(rev.changeType ?? '-'),
-            user: String(rev.userId ?? '-'),
+            // The channel the person's credential came through, when recorded (OSK-16621).
+            user: `${String(rev.userId ?? '-')}${revisionChannelSuffix(rev)}`,
             changes: String(Array.isArray(rev.changes) ? rev.changes.length : 0),
             when: rev.createdAt ? String(rev.createdAt).slice(0, 19).replace('T', ' ') : '-',
         }));

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

@@ -69,6 +69,14 @@ export declare function labelsLine(labelIds?: string[], nameById?: Map<string, s
  * reassigning the task changes only the implied kind.
  */
 export declare function taskExecutorLabel(t: Record<string, unknown>, bin?: string): string;
+/**
+ * The `Resolution:` lines for any resolved Task: how it ended, the reason the
+ * closer recorded, who closed it, and what the close stood on. The reason used to
+ * be JSON-only, so text showed "Task workflow type is cancelled" for every
+ * cancel, and a Task its Workflow step cancelled could not be told from one a
+ * person cancelled by hand (OSK-16475). Silent for an open Task.
+ */
+export declare function resolutionLines(t: Record<string, unknown>, names?: Map<string, string>): string[];
 /**
  * The `Recurrence:` line for a series whose next occurrence was never armed.
  * Silent otherwise: a healthy series has nothing to say here.