@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7195.1.b5efd1d51a

package/src/modules/workflows/backend/work-inbox/page.tsx

@@ -0,0 +1,506 @@
+"use client"
+
+/**
+ * Work Inbox (spec §6.2) — one queue over every registered source.
+ *
+ * Replaces the User Tasks list, which is now a bridge redirect onto this page.
+ * Two things about it are load-bearing:
+ *
+ * - **`perspective.tableId` stays `workflows.tasks.list`.** That id is FROZEN
+ *   (BACKWARD_COMPATIBILITY.md §6): the enterprise agent_orchestrator injects
+ *   its "Review proposal" row action into
+ *   `data-table:workflows.tasks.list:row-actions`, which `DataTable` resolves
+ *   from this exact prop. Renaming it would make that action silently vanish.
+ *   The action reads `row.proposalId`, which the work-inbox row still carries
+ *   because a `user_task` row is a superset of the task row it replaced.
+ * - **Status is never colour-only.** Every badge pairs a design-system status
+ *   token with its own icon and its translated label
+ *   (`lib/work-inbox/presentation.ts`). The retired list used `bg-yellow-100` /
+ *   `bg-blue-100` / `bg-green-100` and `text-red-600`, none of which survive
+ *   dark mode or a colour-blind reader.
+ */
+
+import * as React from 'react'
+import { useRouter } from 'next/navigation'
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { DataTable } from '@open-mercato/ui/backend/DataTable'
+import type { LegacyColumnDef as ColumnDef } from '@tanstack/react-table/legacy'
+import { Alert } from '@open-mercato/ui/primitives/alert'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { RowActions } from '@open-mercato/ui/backend/RowActions'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { useQuery, useQueryClient } from '@tanstack/react-query'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import type { FilterDef, FilterValues } from '@open-mercato/ui/backend/FilterBar'
+import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
+import { WORK_INBOX_PRIORITIES } from '../../lib/work-inbox/provider'
+import type { WorkInboxWireRow } from '../../lib/work-inbox/provider'
+import { buildWorkInboxListQueryParams } from '../../lib/work-inbox/query'
+import { buildWorkInboxItemHref } from '../../lib/work-inbox/navigation'
+import { resolveWorkInboxEmptyState } from '../../lib/work-inbox/empty-state'
+import {
+  WORK_INBOX_OVERDUE_TONE,
+  describeWorkInboxPriority,
+  describeWorkInboxStatus,
+} from '../../lib/work-inbox/presentation'
+import { StatusChip } from '../../components/work-inbox/StatusChip'
+import { WorkInboxEmptyState } from '../../components/work-inbox/WorkInboxEmptyState'
+import { extensionPoints } from '@open-mercato/core/modules/workflows/extension-points'
+
+/**
+ * `data-table:workflows.tasks.list:*` is a FROZEN widget spot id — the
+ * enterprise Caseload row action is wired to it. Never rename this.
+ *
+ * Read from the extension-point catalogue rather than re-typed here: this page
+ * is the declared host, so the literal and the declaration cannot drift apart,
+ * and the module-facts extractor can bind the declaration to its host.
+ */
+const WORK_INBOX_TABLE_ID = extensionPoints.hosts.tasksTable.tableId
+
+const PAGE_SIZE = 50
+
+type WorkInboxResponse = {
+  data: WorkInboxWireRow[]
+  pagination: { total: number; limit: number; offset: number; hasMore: boolean; totalIsCapped?: boolean }
+  meta: { kinds: string[]; degradedKinds: string[] }
+  /**
+   * Present only for a `workflows.tasks.view_all` holder or a superadmin. It is
+   * what turns "the page is shorter than the total and nobody says why" into
+   * "one row is here, you just cannot see its record" (design §3.6).
+   */
+  diagnostics?: { entityHiddenCount: number }
+}
+
+export default function WorkInboxPage() {
+  const [page, setPage] = React.useState(1)
+  const [total, setTotal] = React.useState(0)
+  const [totalPages, setTotalPages] = React.useState(1)
+  const [totalIsCapped, setTotalIsCapped] = React.useState(false)
+  const [availableKinds, setAvailableKinds] = React.useState<string[]>([])
+  const [entityHiddenCount, setEntityHiddenCount] = React.useState(0)
+  const [degradedKinds, setDegradedKinds] = React.useState<string[]>([])
+  const t = useT()
+  const router = useRouter()
+  const queryClient = useQueryClient()
+  const { confirm: confirmDialog, ConfirmDialogElement } = useConfirmDialog()
+  const [filterValues, setFilterValues] = React.useState<FilterValues>({ myWork: 'true' })
+
+  const { data, isLoading, error } = useQuery({
+    queryKey: ['workflow-work-inbox', 'list', filterValues, page],
+    queryFn: async () => {
+      const params = buildWorkInboxListQueryParams(filterValues, {
+        limit: PAGE_SIZE,
+        offset: (page - 1) * PAGE_SIZE,
+      })
+
+      const result = await apiCall<WorkInboxResponse>(`/api/workflows/work-inbox?${params.toString()}`)
+      if (!result.ok) {
+        throw new Error('[internal] work inbox request failed')
+      }
+
+      const response = result.result
+      if (response?.pagination) {
+        setTotal(response.pagination.total || 0)
+        setTotalPages(Math.ceil((response.pagination.total || 0) / PAGE_SIZE) || 1)
+        setTotalIsCapped(response.pagination.totalIsCapped === true)
+      }
+      setEntityHiddenCount(response?.diagnostics?.entityHiddenCount ?? 0)
+      if (response?.meta) {
+        setAvailableKinds(response.meta.kinds ?? [])
+        const degraded = response.meta.degradedKinds ?? []
+        setDegradedKinds(degraded)
+        if (degraded.length > 0) {
+          flash(t('workflows.workInbox.messages.degraded'), 'error')
+        }
+      } else {
+        setDegradedKinds([])
+      }
+
+      return response?.data ?? []
+    },
+  })
+
+  const invalidate = React.useCallback(() => {
+    queryClient.invalidateQueries({ queryKey: ['workflow-work-inbox'] })
+  }, [queryClient])
+
+  const handleClaim = React.useCallback(
+    async (row: WorkInboxWireRow) => {
+      const confirmed = await confirmDialog({
+        title: t('workflows.tasks.confirm.claim', { name: row.title }),
+        variant: 'default',
+      })
+      if (!confirmed) return
+
+      const result = await apiCall(`/api/workflows/tasks/${row.id}/claim`, { method: 'POST' })
+      if (result.ok) {
+        flash(t('workflows.tasks.messages.claimed'), 'success')
+        invalidate()
+      } else {
+        flash(t('workflows.tasks.messages.claimFailed'), 'error')
+      }
+    },
+    [confirmDialog, invalidate, t],
+  )
+
+  const handleRelease = React.useCallback(
+    async (row: WorkInboxWireRow) => {
+      const confirmed = await confirmDialog({
+        title: t('workflows.workInbox.confirm.unclaim', { name: row.title }),
+        variant: 'default',
+      })
+      if (!confirmed) return
+
+      const result = await apiCall(`/api/workflows/tasks/${row.id}/unclaim`, { method: 'POST' })
+      if (result.ok) {
+        flash(t('workflows.workInbox.messages.released'), 'success')
+        invalidate()
+      } else {
+        flash(t('workflows.workInbox.messages.releaseFailed'), 'error')
+      }
+    },
+    [confirmDialog, invalidate, t],
+  )
+
+  const handleClaimNext = React.useCallback(async () => {
+    const result = await apiCall<{ data: WorkInboxWireRow | null }>(
+      '/api/workflows/work-inbox/next',
+      { method: 'POST' },
+    )
+    if (!result.ok) {
+      flash(t('workflows.tasks.messages.claimFailed'), 'error')
+      return
+    }
+    const claimed = result.result?.data ?? null
+    if (!claimed) {
+      flash(t('workflows.workInbox.messages.nothingClaimable'), 'info')
+      return
+    }
+    flash(t('workflows.tasks.messages.claimed'), 'success')
+    invalidate()
+    router.push(buildWorkInboxItemHref(claimed.id))
+  }, [invalidate, router, t])
+
+  const handleFiltersApply = React.useCallback((values: FilterValues) => {
+    const next: FilterValues = {}
+    Object.entries(values).forEach(([key, value]) => {
+      if (value !== undefined && value !== '') next[key] = value
+    })
+    setFilterValues(next)
+    setPage(1)
+  }, [])
+
+  const handleFiltersClear = React.useCallback(() => {
+    setFilterValues({ myWork: 'true' })
+    setPage(1)
+  }, [])
+
+  const filters: FilterDef[] = React.useMemo(
+    () => [
+      {
+        id: 'myWork',
+        type: 'select',
+        label: t('workflows.tasks.filters.view'),
+        options: [
+          { label: t('workflows.workInbox.filters.myWork'), value: 'true' },
+          { label: t('workflows.workInbox.filters.allWork'), value: '' },
+        ],
+      },
+      {
+        id: 'kind',
+        type: 'select',
+        label: t('workflows.workInbox.filters.kind'),
+        options: [
+          { label: t('common.all'), value: '' },
+          ...availableKinds.map((kind) => ({
+            label: t(`workflows.workInbox.kinds.${kind}`, kind),
+            value: kind,
+          })),
+        ],
+      },
+      {
+        id: 'priority',
+        type: 'select',
+        label: t('workflows.workInbox.filters.priority'),
+        options: [
+          { label: t('common.all'), value: '' },
+          ...WORK_INBOX_PRIORITIES.map((priority) => ({
+            label: t(`workflows.workInbox.priorities.${priority}`),
+            value: priority,
+          })),
+        ],
+      },
+      {
+        id: 'status',
+        type: 'select',
+        label: t('workflows.tasks.filters.status'),
+        options: [
+          { label: t('common.all'), value: '' },
+          { label: t('workflows.tasks.statuses.PENDING'), value: 'PENDING' },
+          { label: t('workflows.tasks.statuses.IN_PROGRESS'), value: 'IN_PROGRESS' },
+          { label: t('workflows.tasks.statuses.COMPLETED'), value: 'COMPLETED' },
+          { label: t('workflows.tasks.statuses.CANCELLED'), value: 'CANCELLED' },
+          { label: t('workflows.tasks.statuses.ESCALATED'), value: 'ESCALATED' },
+        ],
+      },
+      {
+        id: 'overdue',
+        type: 'select',
+        label: t('workflows.tasks.filters.overdue'),
+        options: [
+          { label: t('common.all'), value: '' },
+          { label: t('workflows.tasks.filters.overdueOnly'), value: 'true' },
+        ],
+      },
+      {
+        id: 'module',
+        type: 'text',
+        label: t('workflows.workInbox.filters.module'),
+        placeholder: t('workflows.workInbox.filters.modulePlaceholder'),
+      },
+      {
+        id: 'entityType',
+        type: 'text',
+        label: t('workflows.workInbox.filters.entityType'),
+        placeholder: t('workflows.workInbox.filters.entityTypePlaceholder'),
+      },
+      {
+        id: 'role',
+        type: 'text',
+        label: t('workflows.workInbox.filters.role'),
+        placeholder: t('workflows.workInbox.filters.rolePlaceholder'),
+      },
+    ],
+    [availableKinds, t],
+  )
+
+  const columns: ColumnDef<WorkInboxWireRow>[] = React.useMemo(
+    () => [
+      {
+        id: 'title',
+        header: t('workflows.workInbox.fields.item'),
+        accessorKey: 'title',
+        cell: ({ row }) => (
+          <div>
+            <div className="font-medium text-sm">{row.original.title}</div>
+            {row.original.description ? (
+              <div className="text-xs text-muted-foreground line-clamp-1">{row.original.description}</div>
+            ) : null}
+            {row.original.entityBindings.length > 0 ? (
+              <div className="text-xs text-muted-foreground">
+                {row.original.entityBindings
+                  .map((binding) => binding.label || `${binding.entityType} ${binding.entityId}`)
+                  .join(', ')}
+              </div>
+            ) : null}
+            {row.original.overdue ? (
+              <div className="mt-1">
+                <StatusChip
+                  descriptor={WORK_INBOX_OVERDUE_TONE}
+                  label={t('workflows.tasks.overdue')}
+                />
+              </div>
+            ) : null}
+          </div>
+        ),
+      },
+      {
+        id: 'kind',
+        header: t('workflows.workInbox.fields.kind'),
+        accessorKey: 'kind',
+        cell: ({ row }) => (
+          <span className="text-sm text-muted-foreground">
+            {t(`workflows.workInbox.kinds.${row.original.kind}`, row.original.kind)}
+          </span>
+        ),
+      },
+      {
+        id: 'priority',
+        header: t('workflows.workInbox.fields.priority'),
+        accessorKey: 'priority',
+        cell: ({ row }) => {
+          const descriptor = describeWorkInboxPriority(row.original.priority)
+          if (!descriptor) {
+            return <span className="text-sm text-muted-foreground">{t('workflows.workInbox.priorities.unset')}</span>
+          }
+          return (
+            <StatusChip
+              descriptor={descriptor}
+              label={t(`workflows.workInbox.priorities.${row.original.priority}`)}
+            />
+          )
+        },
+      },
+      {
+        id: 'status',
+        header: t('workflows.tasks.fields.status'),
+        accessorKey: 'status',
+        cell: ({ row }) => {
+          const descriptor = describeWorkInboxStatus(row.original.status)
+          return (
+            <StatusChip
+              descriptor={descriptor}
+              label={t(`workflows.tasks.statuses.${row.original.status}`, row.original.status)}
+            />
+          )
+        },
+      },
+      {
+        id: 'assignment',
+        header: t('workflows.tasks.fields.assignment'),
+        cell: ({ row }) => {
+          if (row.original.claimedBy) {
+            return (
+              <div className="text-sm text-foreground">
+                {t('workflows.tasks.claimedBy')}: {row.original.claimedBy}
+              </div>
+            )
+          }
+          if (row.original.assignedTo) {
+            return <div className="text-sm text-foreground">{row.original.assignedTo}</div>
+          }
+          if (row.original.assignedToRoles && row.original.assignedToRoles.length > 0) {
+            return (
+              <div className="text-sm text-muted-foreground">
+                {t('workflows.tasks.roles')}: {row.original.assignedToRoles.join(', ')}
+              </div>
+            )
+          }
+          return <span className="text-sm text-muted-foreground">-</span>
+        },
+      },
+      {
+        id: 'dueDate',
+        header: t('workflows.tasks.fields.dueDate'),
+        accessorKey: 'dueDate',
+        cell: ({ row }) => {
+          if (!row.original.dueDate) {
+            return <span className="text-sm text-muted-foreground">-</span>
+          }
+          const tone = row.original.overdue ? WORK_INBOX_OVERDUE_TONE.text : 'text-foreground'
+          return (
+            <div className={`text-sm ${tone}`}>{new Date(row.original.dueDate).toLocaleString()}</div>
+          )
+        },
+      },
+      {
+        id: 'createdAt',
+        header: t('workflows.tasks.fields.createdAt'),
+        accessorKey: 'createdAt',
+        cell: ({ row }) => (
+          <span className="text-sm text-muted-foreground">
+            {new Date(row.original.createdAt).toLocaleString()}
+          </span>
+        ),
+      },
+      {
+        id: 'actions',
+        header: '',
+        cell: ({ row }) => {
+          const item = row.original
+          const items: Array<{ id: string; label: string; href?: string; onSelect?: () => void }> = []
+
+          if (item.detailHref) {
+            items.push({
+              id: 'view',
+              label: t('workflows.tasks.actions.viewDetails'),
+              href: item.detailHref,
+            })
+          }
+
+          const claimable =
+            item.status === 'PENDING' &&
+            !item.assignedTo &&
+            !item.claimedBy &&
+            (item.assignedToRoles?.length ?? 0) > 0
+
+          if (claimable) {
+            items.push({
+              id: 'claim',
+              label: t('workflows.tasks.actions.claim'),
+              onSelect: () => void handleClaim(item),
+            })
+          }
+
+          if (item.status === 'IN_PROGRESS' && item.claimedBy) {
+            items.push({
+              id: 'unclaim',
+              label: t('workflows.tasks.actions.unclaim'),
+              onSelect: () => void handleRelease(item),
+            })
+          }
+
+          if (item.detailHref && (item.status === 'PENDING' || item.status === 'IN_PROGRESS')) {
+            items.push({
+              id: 'complete',
+              label: t('workflows.tasks.actions.complete'),
+              href: item.detailHref,
+            })
+          }
+
+          return <RowActions items={items} />
+        },
+      },
+    ],
+    [handleClaim, handleRelease, t],
+  )
+
+  const rows = data ?? []
+
+  // §6.4 turned an empty inbox from "there is no work" into a statement about
+  // this account's relationship to the work. Which statement it is belongs to a
+  // PURE resolver, never to this file.
+  const emptyState = React.useMemo(
+    () => resolveWorkInboxEmptyState({ filterValues, entityHiddenCount, degradedKinds }),
+    [degradedKinds, entityHiddenCount, filterValues],
+  )
+
+  return (
+    <Page>
+      <PageBody>
+        {/*
+          The banner explains a page that is SHORTER than its total. With no rows
+          at all the empty state says the same thing in the place the reader is
+          already looking, so showing both would be one message twice.
+        */}
+        {entityHiddenCount > 0 && rows.length > 0 ? (
+          <Alert status="information" className="mb-4">
+            {t('workflows.workInbox.messages.entityHidden', { count: entityHiddenCount })}
+          </Alert>
+        ) : null}
+        <DataTable
+          title={t('workflows.workInbox.list.title')}
+          columns={columns}
+          data={rows}
+          isLoading={isLoading}
+          error={error ? t('workflows.workInbox.messages.loadFailed') : null}
+          filters={filters}
+          filterValues={filterValues}
+          onFiltersApply={handleFiltersApply}
+          onFiltersClear={handleFiltersClear}
+          emptyState={
+            emptyState.kind === 'filtered' ? undefined : <WorkInboxEmptyState state={emptyState} />
+          }
+          // The narrowed case is handed to the shared `FilteredEmptyResults`,
+          // which already owns that copy and the clear-filters affordance.
+          filterAwareEmptyState={{
+            active: emptyState.kind === 'filtered',
+            entityNamePlural: t('workflows.workInbox.empty.entityNamePlural'),
+            canRemoveLast: false,
+            onClearAll: handleFiltersClear,
+            onRemoveLast: handleFiltersClear,
+          }}
+          actions={
+            <Button onClick={() => void handleClaimNext()}>
+              {t('workflows.workInbox.actions.claimNext')}
+            </Button>
+          }
+          perspective={{ tableId: WORK_INBOX_TABLE_ID }}
+          pagination={{ page, pageSize: PAGE_SIZE, total, totalPages, totalIsCapped, onPageChange: setPage }}
+        />
+      </PageBody>
+      {ConfirmDialogElement}
+    </Page>
+  )
+}

package/src/modules/workflows/cli.ts

@@ -149,7 +149,7 @@ const seedSalesPipeline: ModuleCli = {
         workflowId: pipelineData.workflowId,
         tenantId,
         organizationId,
-      })
+      }, { orderBy: { version: 'DESC' } })
 
       if (existing) {
         console.log(`ℹ️  Sales pipeline workflow '${pipelineData.workflowId}' already exists (ID: ${existing.id})`)

package/src/modules/workflows/commands/tasks.ts

@@ -0,0 +1,146 @@
+/**
+ * `workflows.tasks.complete` — the command behind a notification quick action.
+ *
+ * The notifications module executes a `commandId` action through the command
+ * bus after claiming the row with a conditional UPDATE, so a double-click or a
+ * retried request is a 409 rather than a second completion
+ * (`notificationService.executeAction`). That claim is the outer idempotency
+ * guard; `completeUserTask`'s own `status IN (PENDING, IN_PROGRESS)` lookup is
+ * the inner one.
+ *
+ * The command input is `{ id: <userTaskId> }` — the notification's
+ * `sourceEntityId`. It carries no decision, which is precisely why
+ * `lib/task-quick-action.ts` only offers this button for a task with at most
+ * one decision: the sole decision is re-resolved here from the instance's
+ * pinned definition, so a quick action selects exactly the route the full task
+ * page would have.
+ *
+ * Nothing about this path is more permissive than the HTTP route: the caller
+ * must hold `workflows.tasks.complete`, and only the notification's own
+ * recipient can execute an action on it.
+ */
+
+import { z } from 'zod'
+import { registerCommand } from '@open-mercato/shared/lib/commands'
+import type { CommandHandler, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { AwilixContainer } from 'awilix'
+import { UserTask } from '../data/entities'
+import { loadTaskDecisionContext } from '../lib/task-decision-context'
+import type { TaskHandlerService } from '../lib/task-handler'
+
+export const WORKFLOWS_TASK_COMPLETE_COMMAND_ID = 'workflows.tasks.complete'
+
+const COMPLETE_TASK_FEATURE = 'workflows.tasks.complete'
+
+/**
+ * Non-strict on purpose: the notifications module spreads the action payload
+ * into the command input, so unrelated keys must be ignored rather than reject
+ * the whole call.
+ */
+const completeTaskCommandSchema = z.object({
+  id: z.string().uuid(),
+  comments: z.string().optional(),
+})
+
+export type CompleteTaskCommandInput = z.infer<typeof completeTaskCommandSchema>
+
+type RbacServiceLike = {
+  userHasAllFeatures: (
+    userId: string,
+    required: string[],
+    scope: { tenantId: string | null; organizationId: string | null }
+  ) => Promise<boolean>
+}
+
+/**
+ * Fail-closed: no caller identity, no rbacService, or a thrown check all deny.
+ * A command reachable from a notification must never be a softer gate than the
+ * route that does the same thing.
+ */
+async function callerMayCompleteTasks(
+  ctx: CommandRuntimeContext,
+  scope: { tenantId: string; organizationId: string }
+): Promise<boolean> {
+  const userId = ctx.auth?.sub
+  if (!userId) return false
+  try {
+    const rbac = ctx.container.resolve('rbacService') as RbacServiceLike | undefined
+    if (!rbac?.userHasAllFeatures) return false
+    return await rbac.userHasAllFeatures(userId, [COMPLETE_TASK_FEATURE], {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+    })
+  } catch {
+    return false
+  }
+}
+
+const completeUserTaskCommand: CommandHandler<
+  CompleteTaskCommandInput,
+  { taskId: string; decisionId: string | null }
+> = {
+  id: WORKFLOWS_TASK_COMPLETE_COMMAND_ID,
+  async execute(rawInput, ctx) {
+    const parsed = completeTaskCommandSchema.parse(rawInput)
+
+    const userId = ctx.auth?.sub
+    const tenantId = ctx.auth?.tenantId ?? null
+    const organizationId = ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+
+    if (!userId || !tenantId || !organizationId) {
+      throw new Error('[internal] workflows.tasks.complete requires an authenticated caller scope')
+    }
+
+    const scope = { tenantId, organizationId }
+    if (!(await callerMayCompleteTasks(ctx, scope))) {
+      throw new Error('[internal] Caller is not allowed to complete workflow tasks')
+    }
+
+    const container = ctx.container as AwilixContainer
+    const em = (container.resolve('em') as EntityManager).fork()
+
+    const task = await em.findOne(UserTask, {
+      id: parsed.id,
+      tenantId,
+      organizationId,
+      status: { $in: ['PENDING', 'IN_PROGRESS'] },
+    })
+    if (!task) {
+      throw new Error('[internal] Task not found or already completed')
+    }
+
+    // Re-resolved from the pinned definition, exactly as the task page does.
+    // More than one decision means the quick action should never have been
+    // offered (see `lib/task-quick-action.ts`), so refuse rather than pick one.
+    const { decisions } = await loadTaskDecisionContext(em, task)
+    if (decisions.length > 1) {
+      throw new Error('[internal] Task offers multiple decisions and cannot be completed in one click')
+    }
+    const decisionId = decisions[0]?.id ?? null
+
+    const taskHandler = container.resolve('taskHandler') as TaskHandlerService
+    await taskHandler.completeUserTask(em, container, {
+      taskId: task.id,
+      formData: {},
+      userId,
+      comments: parsed.comments,
+      ...(decisionId ? { decisionId } : {}),
+      scope,
+    })
+
+    return { taskId: task.id, decisionId }
+  },
+  buildLog({ input, result }) {
+    return {
+      resourceKind: 'workflows.user_task',
+      resourceId: result?.taskId ?? input.id,
+      actionLabel: 'workflows.tasks.complete',
+      payload: { decisionId: result?.decisionId ?? null },
+    }
+  },
+}
+
+registerCommand(completeUserTaskCommand)
+
+export default completeUserTaskCommand