@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7194.1.ab4fc81f82

package/dist/modules/workflows/lib/task-presets.js

@@ -0,0 +1,35 @@
+import {
+  newDecisionDraft,
+  newEntityBindingDraft
+} from "./task-inspector-config.js";
+const APPROVAL_PRESET_COMMENT_FIELD = "comment";
+function buildApprovalPreset(input) {
+  const decisions = [...input.decisions ?? []];
+  const boundRoutes = new Set(decisions.map((decision) => decision.transitionId).filter(Boolean));
+  const addDecision = (label, transitionId, style) => {
+    if (transitionId && boundRoutes.has(transitionId)) return;
+    const draft = newDecisionDraft(transitionId);
+    decisions.push({ ...draft, label, style });
+    if (transitionId) boundRoutes.add(transitionId);
+  };
+  addDecision(input.approveLabel, input.approveTransitionId ?? "", "primary");
+  addDecision(input.rejectLabel, input.rejectTransitionId ?? "", "destructive");
+  const formFields = [...input.formFields ?? []];
+  if (!formFields.some((field) => field.name === APPROVAL_PRESET_COMMENT_FIELD)) {
+    formFields.push({
+      name: APPROVAL_PRESET_COMMENT_FIELD,
+      type: "textarea",
+      label: input.commentLabel,
+      required: false
+    });
+  }
+  const entityBindings = [...input.entityBindings ?? []];
+  const promptsForEntityBinding = entityBindings.length === 0;
+  if (promptsForEntityBinding) entityBindings.push(newEntityBindingDraft());
+  return { decisions, formFields, entityBindings, promptsForEntityBinding };
+}
+export {
+  APPROVAL_PRESET_COMMENT_FIELD,
+  buildApprovalPreset
+};
+//# sourceMappingURL=task-presets.js.map

package/dist/modules/workflows/lib/task-presets.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-presets.ts"],
+  "sourcesContent": ["/**\n * Task presets (spec \u00A76.1, item 7).\n *\n * PURE: a preset is a data transformation over the inspector's drafts, so the\n * shape it produces is unit-testable \u2014 and provable to parse \u2014 without opening\n * the editor. Every piece of author-facing copy is passed IN by the caller,\n * which is what keeps the labels translated (`useT` lives in the component)\n * while the rule about what a preset contains lives here.\n */\n\nimport type { FormField } from '../components/fields/FormFieldArrayEditor'\nimport {\n  newDecisionDraft,\n  newEntityBindingDraft,\n  type TaskDecisionDraft,\n  type TaskEntityBindingDraft,\n} from './task-inspector-config'\n\nexport const APPROVAL_PRESET_COMMENT_FIELD = 'comment'\n\nexport interface ApprovalPresetCopy {\n  approveLabel: string\n  rejectLabel: string\n  commentLabel: string\n}\n\nexport interface ApprovalPresetRoutes {\n  /** Durable transition ids of the step's outgoing routes, in evaluation order. */\n  approveTransitionId?: string\n  rejectTransitionId?: string\n}\n\nexport interface ApprovalPresetInput extends ApprovalPresetCopy, ApprovalPresetRoutes {\n  decisions?: TaskDecisionDraft[]\n  formFields?: FormField[]\n  entityBindings?: TaskEntityBindingDraft[]\n}\n\nexport interface ApprovalPresetResult {\n  decisions: TaskDecisionDraft[]\n  formFields: FormField[]\n  entityBindings: TaskEntityBindingDraft[]\n  /** True when the preset left an empty binding row for the author to complete. */\n  promptsForEntityBinding: boolean\n}\n\n/**\n * Approve / Reject plus a comment field, bound to the step's first two\n * outgoing routes.\n *\n * Three deliberate choices:\n *\n * - It is ADDITIVE. Existing decisions, form fields and bindings are kept, and\n *   a decision already bound to a route the preset would use is left alone \u2014\n *   applying the preset twice must not double the buttons or overwrite copy an\n *   author wrote.\n * - Routes are bound by their DURABLE ids, taken from the step's real outgoing\n *   transitions. When a route is missing the button is still created with an\n *   empty binding rather than an invented id: an unbound button is visible and\n *   fixable, a fabricated id is a silently broken workflow.\n * - It PROMPTS for the entity binding rather than guessing one. An approval is\n *   always an approval OF something, and the ledger path that yields that\n *   record is the one thing a preset genuinely cannot know, so it seeds an\n *   empty binding row instead of leaving the section untouched.\n */\nexport function buildApprovalPreset(input: ApprovalPresetInput): ApprovalPresetResult {\n  const decisions = [...(input.decisions ?? [])]\n  const boundRoutes = new Set(decisions.map((decision) => decision.transitionId).filter(Boolean))\n\n  const addDecision = (label: string, transitionId: string, style: TaskDecisionDraft['style']) => {\n    if (transitionId && boundRoutes.has(transitionId)) return\n    const draft = newDecisionDraft(transitionId)\n    decisions.push({ ...draft, label, style })\n    if (transitionId) boundRoutes.add(transitionId)\n  }\n\n  addDecision(input.approveLabel, input.approveTransitionId ?? '', 'primary')\n  addDecision(input.rejectLabel, input.rejectTransitionId ?? '', 'destructive')\n\n  const formFields = [...(input.formFields ?? [])]\n  if (!formFields.some((field) => field.name === APPROVAL_PRESET_COMMENT_FIELD)) {\n    formFields.push({\n      name: APPROVAL_PRESET_COMMENT_FIELD,\n      type: 'textarea',\n      label: input.commentLabel,\n      required: false,\n    })\n  }\n\n  const entityBindings = [...(input.entityBindings ?? [])]\n  const promptsForEntityBinding = entityBindings.length === 0\n  if (promptsForEntityBinding) entityBindings.push(newEntityBindingDraft())\n\n  return { decisions, formFields, entityBindings, promptsForEntityBinding }\n}\n"],
+  "mappings": "AAWA;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAEA,MAAM,gCAAgC;AA+CtC,SAAS,oBAAoB,OAAkD;AACpF,QAAM,YAAY,CAAC,GAAI,MAAM,aAAa,CAAC,CAAE;AAC7C,QAAM,cAAc,IAAI,IAAI,UAAU,IAAI,CAAC,aAAa,SAAS,YAAY,EAAE,OAAO,OAAO,CAAC;AAE9F,QAAM,cAAc,CAAC,OAAe,cAAsB,UAAsC;AAC9F,QAAI,gBAAgB,YAAY,IAAI,YAAY,EAAG;AACnD,UAAM,QAAQ,iBAAiB,YAAY;AAC3C,cAAU,KAAK,EAAE,GAAG,OAAO,OAAO,MAAM,CAAC;AACzC,QAAI,aAAc,aAAY,IAAI,YAAY;AAAA,EAChD;AAEA,cAAY,MAAM,cAAc,MAAM,uBAAuB,IAAI,SAAS;AAC1E,cAAY,MAAM,aAAa,MAAM,sBAAsB,IAAI,aAAa;AAE5E,QAAM,aAAa,CAAC,GAAI,MAAM,cAAc,CAAC,CAAE;AAC/C,MAAI,CAAC,WAAW,KAAK,CAAC,UAAU,MAAM,SAAS,6BAA6B,GAAG;AAC7E,eAAW,KAAK;AAAA,MACd,MAAM;AAAA,MACN,MAAM;AAAA,MACN,OAAO,MAAM;AAAA,MACb,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AAEA,QAAM,iBAAiB,CAAC,GAAI,MAAM,kBAAkB,CAAC,CAAE;AACvD,QAAM,0BAA0B,eAAe,WAAW;AAC1D,MAAI,wBAAyB,gBAAe,KAAK,sBAAsB,CAAC;AAExE,SAAO,EAAE,WAAW,YAAY,gBAAgB,wBAAwB;AAC1E;",
+  "names": []
+}

package/dist/modules/workflows/lib/task-quick-action.js

@@ -0,0 +1,45 @@
+import { countTaskFormFields } from "./task-form-schema.js";
+const TASK_COMPLETE_COMMAND_ID = "workflows.tasks.complete";
+const TASK_QUICK_ACTION_COMPLETE_ID = "complete";
+const TASK_QUICK_ACTION_VIEW_ID = "view";
+const TASK_DEEP_LINK_HREF = "/backend/tasks/{sourceEntityId}";
+function isOneClickTask(input) {
+  if (input.requiresComment) return false;
+  if (input.editablePrefilled?.length) return false;
+  if (countTaskFormFields(input.formSchema) > 0) return false;
+  const decisions = input.decisions ?? [];
+  return decisions.length <= 1;
+}
+function buildTaskQuickActions(input) {
+  const viewAction = {
+    id: TASK_QUICK_ACTION_VIEW_ID,
+    labelKey: "common.view",
+    variant: "outline",
+    href: TASK_DEEP_LINK_HREF,
+    icon: "external-link"
+  };
+  if (!isOneClickTask(input)) return [viewAction];
+  return [
+    viewAction,
+    {
+      id: TASK_QUICK_ACTION_COMPLETE_ID,
+      labelKey: "workflows.notifications.task.actions.complete",
+      variant: "default",
+      icon: "check",
+      commandId: TASK_COMPLETE_COMMAND_ID
+    }
+  ];
+}
+function resolveTaskPrimaryActionId(input) {
+  return isOneClickTask(input) ? TASK_QUICK_ACTION_COMPLETE_ID : TASK_QUICK_ACTION_VIEW_ID;
+}
+export {
+  TASK_COMPLETE_COMMAND_ID,
+  TASK_DEEP_LINK_HREF,
+  TASK_QUICK_ACTION_COMPLETE_ID,
+  TASK_QUICK_ACTION_VIEW_ID,
+  buildTaskQuickActions,
+  isOneClickTask,
+  resolveTaskPrimaryActionId
+};
+//# sourceMappingURL=task-quick-action.js.map

package/dist/modules/workflows/lib/task-quick-action.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-quick-action.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - Notification quick-action rule (pure)\n *\n * Spec \u00A76.2: *\"Notification quick-actions complete a decision inline **only\n * when** the task has exactly one-click semantics: no editable-prefilled fields\n * and no required comment \u2014 otherwise the quick action deep-links to the full\n * task.\"*\n *\n * What \"one click\" means here, and why each clause is load-bearing:\n *\n *  - **Exactly one decision, or none.** A notification action carries an\n *    `actionId`; the notifications module builds the command input from the\n *    notification's `sourceEntityId` alone (`notificationService.executeAction`),\n *    so WHICH of several buttons was pressed cannot reach the command. Two\n *    decisions therefore cannot be distinguished from a notification, and the\n *    honest answer is the deep link. (The platform's other command-backed\n *    notification \u2014 `staff.leave_request.pending` \u2014 sidesteps this by giving\n *    each button its OWN command id; workflow decisions are per-task data, so\n *    that is not available here.)\n *  - **No form fields.** Anything the assignee may type is input the quick\n *    action cannot collect, and completing with an empty payload would either\n *    fail `validateFormData` or silently discard what the author asked for.\n *  - **No editable-prefilled fields**, verbatim from the spec \u2014 a reviewer who\n *    is meant to correct data inline is not a one-click reviewer.\n *  - **No required comment.** There is no authoring surface for this today (the\n *    task detail's comment box is always optional), so the input defaults to\n *    false; it is modelled explicitly so the rule does not have to be rewritten\n *    when one appears.\n *\n * PURE: no ORM, DI, React or registry imports.\n */\n\nimport type { NotificationTypeAction } from '@open-mercato/shared/modules/notifications/types'\nimport { countTaskFormFields } from './task-form-schema'\n\nexport const TASK_COMPLETE_COMMAND_ID = 'workflows.tasks.complete'\n\n/** Action id of the one-click completion button. */\nexport const TASK_QUICK_ACTION_COMPLETE_ID = 'complete'\n\n/** Action id of the deep link to the full task. */\nexport const TASK_QUICK_ACTION_VIEW_ID = 'view'\n\nexport const TASK_DEEP_LINK_HREF = '/backend/tasks/{sourceEntityId}'\n\nexport interface TaskQuickActionInput {\n  /** Decision buttons resolved for this task. */\n  decisions?: { id: string }[] | null\n  /** The authored form schema, in either accepted shape. */\n  formSchema?: unknown\n  /** Form fields the assignee may correct before deciding. */\n  editablePrefilled?: string[] | null\n  /** Reserved: no authoring surface exists yet, so callers leave it unset. */\n  requiresComment?: boolean\n}\n\n/**\n * Whether this task can be finished from a notification with one click.\n *\n * Fail-closed by construction: every clause has to hold, and an unrecognised\n * form schema shape counts as \"has fields\" only when it actually declares any,\n * so a malformed schema degrades to the deep link rather than to a completion\n * that drops data.\n */\nexport function isOneClickTask(input: TaskQuickActionInput): boolean {\n  if (input.requiresComment) return false\n  if (input.editablePrefilled?.length) return false\n  if (countTaskFormFields(input.formSchema) > 0) return false\n\n  const decisions = input.decisions ?? []\n  return decisions.length <= 1\n}\n\n/**\n * The actions a task notification offers.\n *\n * A one-click task gets the command-backed completion button; anything else\n * gets the deep link, which is what the spec's \"otherwise\" clause asks for. The\n * deep link is present in BOTH cases \u2014 a quick action is a shortcut, never the\n * only way to reach the task.\n */\nexport function buildTaskQuickActions(input: TaskQuickActionInput): NotificationTypeAction[] {\n  const viewAction: NotificationTypeAction = {\n    id: TASK_QUICK_ACTION_VIEW_ID,\n    labelKey: 'common.view',\n    variant: 'outline',\n    href: TASK_DEEP_LINK_HREF,\n    icon: 'external-link',\n  }\n\n  if (!isOneClickTask(input)) return [viewAction]\n\n  return [\n    viewAction,\n    {\n      id: TASK_QUICK_ACTION_COMPLETE_ID,\n      labelKey: 'workflows.notifications.task.actions.complete',\n      variant: 'default',\n      icon: 'check',\n      commandId: TASK_COMPLETE_COMMAND_ID,\n    },\n  ]\n}\n\n/**\n * The primary action id for a task notification: the completion button when\n * there is one, otherwise the deep link.\n */\nexport function resolveTaskPrimaryActionId(input: TaskQuickActionInput): string {\n  return isOneClickTask(input) ? TASK_QUICK_ACTION_COMPLETE_ID : TASK_QUICK_ACTION_VIEW_ID\n}\n"],
+  "mappings": "AAiCA,SAAS,2BAA2B;AAE7B,MAAM,2BAA2B;AAGjC,MAAM,gCAAgC;AAGtC,MAAM,4BAA4B;AAElC,MAAM,sBAAsB;AAqB5B,SAAS,eAAe,OAAsC;AACnE,MAAI,MAAM,gBAAiB,QAAO;AAClC,MAAI,MAAM,mBAAmB,OAAQ,QAAO;AAC5C,MAAI,oBAAoB,MAAM,UAAU,IAAI,EAAG,QAAO;AAEtD,QAAM,YAAY,MAAM,aAAa,CAAC;AACtC,SAAO,UAAU,UAAU;AAC7B;AAUO,SAAS,sBAAsB,OAAuD;AAC3F,QAAM,aAAqC;AAAA,IACzC,IAAI;AAAA,IACJ,UAAU;AAAA,IACV,SAAS;AAAA,IACT,MAAM;AAAA,IACN,MAAM;AAAA,EACR;AAEA,MAAI,CAAC,eAAe,KAAK,EAAG,QAAO,CAAC,UAAU;AAE9C,SAAO;AAAA,IACL;AAAA,IACA;AAAA,MACE,IAAI;AAAA,MACJ,UAAU;AAAA,MACV,SAAS;AAAA,MACT,MAAM;AAAA,MACN,WAAW;AAAA,IACb;AAAA,EACF;AACF;AAMO,SAAS,2BAA2B,OAAqC;AAC9E,SAAO,eAAe,KAAK,IAAI,gCAAgC;AACjE;",
+  "names": []
+}

package/dist/modules/workflows/lib/task-resolution.js

@@ -0,0 +1,120 @@
+const TOKEN_PATTERN = /\{\{[^}]+\}\}/;
+function isUnresolved(value) {
+  return typeof value === "string" && TOKEN_PATTERN.test(value);
+}
+function toResolvedString(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed.length || isUnresolved(trimmed)) return null;
+    return trimmed;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return null;
+}
+function resolveTaskText(value, interpolate) {
+  if (value == null) return null;
+  if (typeof value === "string") {
+    const resolved2 = interpolate(value);
+    return typeof resolved2 === "string" ? resolved2 : String(resolved2 ?? "");
+  }
+  const resolved = {};
+  for (const [locale, text] of Object.entries(value)) {
+    const localeValue = interpolate(text);
+    resolved[locale] = typeof localeValue === "string" ? localeValue : String(localeValue ?? "");
+  }
+  return resolved;
+}
+function flattenTaskText(value, locale) {
+  if (value == null) return null;
+  if (typeof value === "string") return value.length ? value : null;
+  if (locale && typeof value[locale] === "string" && value[locale].length) return value[locale];
+  for (const text of Object.values(value)) {
+    if (typeof text === "string" && text.length) return text;
+  }
+  return null;
+}
+function resolveTaskAssignment(config, interpolate) {
+  const authoredRoles = config.assignedToRoles?.length ? config.assignedToRoles : null;
+  const wantsCustomer = config.assigneeKind === "customer";
+  if (Array.isArray(config.assignedTo)) {
+    return {
+      assignedTo: null,
+      assignedToRoles: config.assignedTo.length ? config.assignedTo : authoredRoles,
+      fellBackToRoles: false,
+      assigneeKind: "user",
+      fellBackFromCustomer: wantsCustomer
+    };
+  }
+  if (typeof config.assignedTo !== "string" || !config.assignedTo.length) {
+    return {
+      assignedTo: null,
+      assignedToRoles: authoredRoles,
+      fellBackToRoles: false,
+      assigneeKind: "user",
+      fellBackFromCustomer: wantsCustomer
+    };
+  }
+  const resolved = toResolvedString(interpolate(config.assignedTo));
+  if (resolved) {
+    return {
+      assignedTo: resolved,
+      assignedToRoles: wantsCustomer ? null : authoredRoles,
+      fellBackToRoles: false,
+      assigneeKind: wantsCustomer ? "customer" : "user",
+      fellBackFromCustomer: false
+    };
+  }
+  return {
+    assignedTo: null,
+    assignedToRoles: authoredRoles,
+    fellBackToRoles: true,
+    assigneeKind: "user",
+    fellBackFromCustomer: wantsCustomer
+  };
+}
+function resolveTaskEntityBindings(bindings, interpolate) {
+  if (!bindings?.length) return { bindings: [], unresolved: [] };
+  const resolvedBindings = [];
+  const unresolved = [];
+  for (const binding of bindings) {
+    const expression = TOKEN_PATTERN.test(binding.idPath) ? binding.idPath : `{{${binding.idPath}}}`;
+    const entityId = toResolvedString(interpolate(expression));
+    if (!entityId) {
+      unresolved.push(binding.idPath);
+      continue;
+    }
+    const label = resolveTaskText(binding.label, interpolate);
+    resolvedBindings.push({
+      entityType: binding.entityType,
+      entityId,
+      ...label != null ? { label } : {}
+    });
+  }
+  return { bindings: resolvedBindings, unresolved };
+}
+function collectResolvedEntityTypes(bindings) {
+  return [...new Set(bindings.map((binding) => binding.entityType))];
+}
+function resolveTaskDecisions(decisions, interpolate) {
+  if (!decisions?.length) return [];
+  return decisions.map((decision) => ({
+    id: decision.id,
+    label: resolveTaskText(decision.label, interpolate) ?? decision.id,
+    transitionId: decision.transitionId,
+    ...decision.style ? { style: decision.style } : {}
+  }));
+}
+function resolveTaskDeadlineDuration(config) {
+  const duration = config.deadline?.duration ?? config.slaDuration;
+  return typeof duration === "string" && duration.length ? duration : null;
+}
+export {
+  collectResolvedEntityTypes,
+  flattenTaskText,
+  resolveTaskAssignment,
+  resolveTaskDeadlineDuration,
+  resolveTaskDecisions,
+  resolveTaskEntityBindings,
+  resolveTaskText
+};
+//# sourceMappingURL=task-resolution.js.map

package/dist/modules/workflows/lib/task-resolution.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-resolution.ts"],
+  "sourcesContent": ["import type {\n  TaskDecision,\n  TaskEntityBinding,\n  TaskLocalizedString,\n  UserTaskAssigneeKind,\n  UserTaskConfig,\n} from '../data/validators'\n\n/**\n * Resolving what a task author wrote into what a task actually says.\n *\n * PURE by construction (no ORM, DI, React or registry imports): the caller\n * supplies an `interpolate` function, which in the engine is the Phase-2b\n * `interpolateVariables` bound to the instance context. That keeps every rule\n * here unit-testable without a workflow, and lets the task surfaces re-resolve\n * copy with the same code the engine used at creation time.\n *\n * Interpolation is deliberately LENIENT here, never strict. A dynamic assignee\n * that resolves to nothing is not an error \u2014 it is exactly the case the spec's\n * mandatory fallback role exists for, and failing the step instead would strand\n * the run over a piece of copy.\n */\n\nexport type TaskInterpolate = (value: unknown) => unknown\n\nexport interface ResolvedTaskEntityBinding {\n  entityType: string\n  entityId: string\n  label?: TaskLocalizedString\n}\n\nexport interface ResolvedTaskAssignment {\n  assignedTo: string | null\n  assignedToRoles: string[] | null\n  /** True when a dynamic assignee was authored and resolved to nothing. */\n  fellBackToRoles: boolean\n  /**\n   * Which principal namespace `assignedTo` names \u2014 the `user_tasks.assignee_kind`\n   * discriminator, decided here so every creation site gets the same answer.\n   *\n   * `'customer'` requires BOTH that the author asked for it AND that an\n   * individual assignee actually resolved. A customer-addressed task with no\n   * assignee is unaddressable: portal principals cannot claim from a queue, and\n   * the portal branch of the visibility predicate has no arm that would ever\n   * admit it.\n   */\n  assigneeKind: UserTaskAssigneeKind\n  /**\n   * True when the author asked for a portal assignee and the dynamic id resolved\n   * to nothing, so the task fell back to the authored backoffice role queue.\n   * Worth a log line: the work is still reachable, but by a different audience\n   * than the author intended.\n   */\n  fellBackFromCustomer: boolean\n}\n\nexport interface ResolvedTaskDecision {\n  id: string\n  label: TaskLocalizedString\n  transitionId: string\n  style?: TaskDecision['style']\n}\n\nconst TOKEN_PATTERN = /\\{\\{[^}]+\\}\\}/\n\nfunction isUnresolved(value: unknown): boolean {\n  return typeof value === 'string' && TOKEN_PATTERN.test(value)\n}\n\nfunction toResolvedString(value: unknown): string | null {\n  if (typeof value === 'string') {\n    const trimmed = value.trim()\n    if (!trimmed.length || isUnresolved(trimmed)) return null\n    return trimmed\n  }\n  if (typeof value === 'number' && Number.isFinite(value)) return String(value)\n  return null\n}\n\n/**\n * Resolve author copy that may be a plain string or a per-locale map. Every\n * leaf goes through the interpolator, so a pill works in either shape.\n */\nexport function resolveTaskText(\n  value: TaskLocalizedString | undefined | null,\n  interpolate: TaskInterpolate\n): TaskLocalizedString | null {\n  if (value == null) return null\n  if (typeof value === 'string') {\n    const resolved = interpolate(value)\n    return typeof resolved === 'string' ? resolved : String(resolved ?? '')\n  }\n  const resolved: Record<string, string> = {}\n  for (const [locale, text] of Object.entries(value)) {\n    const localeValue = interpolate(text)\n    resolved[locale] = typeof localeValue === 'string' ? localeValue : String(localeValue ?? '')\n  }\n  return resolved\n}\n\n/**\n * Flatten localized copy onto the single text column a `UserTask` has. Prefers\n * the requested locale, then the first declared one \u2014 a task must never render\n * blank because its author wrote only one locale.\n */\nexport function flattenTaskText(\n  value: TaskLocalizedString | null | undefined,\n  locale?: string\n): string | null {\n  if (value == null) return null\n  if (typeof value === 'string') return value.length ? value : null\n  if (locale && typeof value[locale] === 'string' && value[locale].length) return value[locale]\n  for (const text of Object.values(value)) {\n    if (typeof text === 'string' && text.length) return text\n  }\n  return null\n}\n\n/**\n * Resolve the assignment the author configured.\n *\n * A `Dynamic` assignment is a pill in `assignedTo` (`{{context.deal.ownerId}}`).\n * When it resolves to nothing \u2014 the path is missing, the value is empty, or the\n * token survived interpolation unchanged \u2014 the task falls to the authored role\n * queue rather than being created with nobody able to see it. That queue IS the\n * spec's mandatory fallback role; the inspector is what makes it mandatory.\n *\n * The legacy array form of `assignedTo` keeps meaning \"these are roles\".\n *\n * ## `assigneeKind`\n *\n * `userTaskConfig.assigneeKind: 'customer'` is what addresses a task to a PORTAL\n * principal \u2014 the id in `assignedTo` is then a `CustomerUser.id`, not a\n * backoffice user id, and only the portal routes can see or complete it. It is\n * honoured only when an individual assignee actually resolves, and it forces\n * `assignedToRoles` to null: portal roles are a different namespace\n * (`CustomerRole`), a backoffice role queue on a customer-addressed row would\n * offer the work to an audience that can never reach it, and design \u00A77.1 makes\n * that combination an invariant rather than a preference.\n *\n * Absent (every definition authored before this existed), the answer is `'user'`\n * \u2014 which is exactly what those rows have always meant.\n */\nexport function resolveTaskAssignment(\n  config: Pick<UserTaskConfig, 'assignedTo' | 'assignedToRoles' | 'assigneeKind'>,\n  interpolate: TaskInterpolate\n): ResolvedTaskAssignment {\n  const authoredRoles = config.assignedToRoles?.length ? config.assignedToRoles : null\n  const wantsCustomer = config.assigneeKind === 'customer'\n\n  if (Array.isArray(config.assignedTo)) {\n    return {\n      assignedTo: null,\n      assignedToRoles: config.assignedTo.length ? config.assignedTo : authoredRoles,\n      fellBackToRoles: false,\n      assigneeKind: 'user',\n      fellBackFromCustomer: wantsCustomer,\n    }\n  }\n\n  if (typeof config.assignedTo !== 'string' || !config.assignedTo.length) {\n    return {\n      assignedTo: null,\n      assignedToRoles: authoredRoles,\n      fellBackToRoles: false,\n      assigneeKind: 'user',\n      fellBackFromCustomer: wantsCustomer,\n    }\n  }\n\n  const resolved = toResolvedString(interpolate(config.assignedTo))\n  if (resolved) {\n    return {\n      assignedTo: resolved,\n      assignedToRoles: wantsCustomer ? null : authoredRoles,\n      fellBackToRoles: false,\n      assigneeKind: wantsCustomer ? 'customer' : 'user',\n      fellBackFromCustomer: false,\n    }\n  }\n\n  return {\n    assignedTo: null,\n    assignedToRoles: authoredRoles,\n    fellBackToRoles: true,\n    assigneeKind: 'user',\n    fellBackFromCustomer: wantsCustomer,\n  }\n}\n\n/**\n * Resolve each binding's `idPath` against the run context.\n *\n * A binding whose id does not resolve is DROPPED, not carried as a dangling\n * reference: the ledger marks plenty of paths `maybe`-presence, so an absent\n * record is an ordinary outcome and a task about \"order #undefined\" is worse\n * than a task about nothing. `unresolved` names what was dropped so the caller\n * can log it.\n */\nexport function resolveTaskEntityBindings(\n  bindings: TaskEntityBinding[] | undefined | null,\n  interpolate: TaskInterpolate\n): { bindings: ResolvedTaskEntityBinding[]; unresolved: string[] } {\n  if (!bindings?.length) return { bindings: [], unresolved: [] }\n\n  const resolvedBindings: ResolvedTaskEntityBinding[] = []\n  const unresolved: string[] = []\n\n  for (const binding of bindings) {\n    const expression = TOKEN_PATTERN.test(binding.idPath) ? binding.idPath : `{{${binding.idPath}}}`\n    const entityId = toResolvedString(interpolate(expression))\n    if (!entityId) {\n      unresolved.push(binding.idPath)\n      continue\n    }\n    const label = resolveTaskText(binding.label, interpolate)\n    resolvedBindings.push({\n      entityType: binding.entityType,\n      entityId,\n      ...(label != null ? { label } : {}),\n    })\n  }\n\n  return { bindings: resolvedBindings, unresolved }\n}\n\n/**\n * The distinct AUTHORED entity types across a task's resolved bindings, for the\n * denormalized `user_tasks.entity_types` column the \u00A76.4 entity gate filters on.\n *\n * Verbatim, deduped, order-preserving. Verbatim because the visibility\n * predicate's per-request access map is keyed on exactly the string the binding\n * carries \u2014 normalizing here would give the SQL filter and the JS predicate two\n * different notions of \"the same type\".\n *\n * Empty in, empty out: the caller stores NULL for a task about nothing, which is\n * what the vacuous-pass rule reads. Same expression the work-inbox projection\n * already computes per row, so a row's stored column and its projected\n * `entityTypes` cannot disagree.\n */\nexport function collectResolvedEntityTypes(\n  bindings: readonly ResolvedTaskEntityBinding[],\n): string[] {\n  return [...new Set(bindings.map((binding) => binding.entityType))]\n}\n\n/** Resolve decision-button copy; the route binding itself is already durable. */\nexport function resolveTaskDecisions(\n  decisions: TaskDecision[] | undefined | null,\n  interpolate: TaskInterpolate\n): ResolvedTaskDecision[] {\n  if (!decisions?.length) return []\n  return decisions.map((decision) => ({\n    id: decision.id,\n    label: resolveTaskText(decision.label, interpolate) ?? decision.id,\n    transitionId: decision.transitionId,\n    ...(decision.style ? { style: decision.style } : {}),\n  }))\n}\n\n/**\n * The authored deadline duration. `deadline` is the business-word superset;\n * `slaDuration` is the original bare-duration form and keeps working forever.\n */\nexport function resolveTaskDeadlineDuration(\n  config: Pick<UserTaskConfig, 'deadline' | 'slaDuration'>\n): string | null {\n  const duration = config.deadline?.duration ?? config.slaDuration\n  return typeof duration === 'string' && duration.length ? duration : null\n}\n"],
+  "mappings": "AA+DA,MAAM,gBAAgB;AAEtB,SAAS,aAAa,OAAyB;AAC7C,SAAO,OAAO,UAAU,YAAY,cAAc,KAAK,KAAK;AAC9D;AAEA,SAAS,iBAAiB,OAA+B;AACvD,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,UAAU,MAAM,KAAK;AAC3B,QAAI,CAAC,QAAQ,UAAU,aAAa,OAAO,EAAG,QAAO;AACrD,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,YAAY,OAAO,SAAS,KAAK,EAAG,QAAO,OAAO,KAAK;AAC5E,SAAO;AACT;AAMO,SAAS,gBACd,OACA,aAC4B;AAC5B,MAAI,SAAS,KAAM,QAAO;AAC1B,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAMA,YAAW,YAAY,KAAK;AAClC,WAAO,OAAOA,cAAa,WAAWA,YAAW,OAAOA,aAAY,EAAE;AAAA,EACxE;AACA,QAAM,WAAmC,CAAC;AAC1C,aAAW,CAAC,QAAQ,IAAI,KAAK,OAAO,QAAQ,KAAK,GAAG;AAClD,UAAM,cAAc,YAAY,IAAI;AACpC,aAAS,MAAM,IAAI,OAAO,gBAAgB,WAAW,cAAc,OAAO,eAAe,EAAE;AAAA,EAC7F;AACA,SAAO;AACT;AAOO,SAAS,gBACd,OACA,QACe;AACf,MAAI,SAAS,KAAM,QAAO;AAC1B,MAAI,OAAO,UAAU,SAAU,QAAO,MAAM,SAAS,QAAQ;AAC7D,MAAI,UAAU,OAAO,MAAM,MAAM,MAAM,YAAY,MAAM,MAAM,EAAE,OAAQ,QAAO,MAAM,MAAM;AAC5F,aAAW,QAAQ,OAAO,OAAO,KAAK,GAAG;AACvC,QAAI,OAAO,SAAS,YAAY,KAAK,OAAQ,QAAO;AAAA,EACtD;AACA,SAAO;AACT;AA2BO,SAAS,sBACd,QACA,aACwB;AACxB,QAAM,gBAAgB,OAAO,iBAAiB,SAAS,OAAO,kBAAkB;AAChF,QAAM,gBAAgB,OAAO,iBAAiB;AAE9C,MAAI,MAAM,QAAQ,OAAO,UAAU,GAAG;AACpC,WAAO;AAAA,MACL,YAAY;AAAA,MACZ,iBAAiB,OAAO,WAAW,SAAS,OAAO,aAAa;AAAA,MAChE,iBAAiB;AAAA,MACjB,cAAc;AAAA,MACd,sBAAsB;AAAA,IACxB;AAAA,EACF;AAEA,MAAI,OAAO,OAAO,eAAe,YAAY,CAAC,OAAO,WAAW,QAAQ;AACtE,WAAO;AAAA,MACL,YAAY;AAAA,MACZ,iBAAiB;AAAA,MACjB,iBAAiB;AAAA,MACjB,cAAc;AAAA,MACd,sBAAsB;AAAA,IACxB;AAAA,EACF;AAEA,QAAM,WAAW,iBAAiB,YAAY,OAAO,UAAU,CAAC;AAChE,MAAI,UAAU;AACZ,WAAO;AAAA,MACL,YAAY;AAAA,MACZ,iBAAiB,gBAAgB,OAAO;AAAA,MACxC,iBAAiB;AAAA,MACjB,cAAc,gBAAgB,aAAa;AAAA,MAC3C,sBAAsB;AAAA,IACxB;AAAA,EACF;AAEA,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,iBAAiB;AAAA,IACjB,iBAAiB;AAAA,IACjB,cAAc;AAAA,IACd,sBAAsB;AAAA,EACxB;AACF;AAWO,SAAS,0BACd,UACA,aACiE;AACjE,MAAI,CAAC,UAAU,OAAQ,QAAO,EAAE,UAAU,CAAC,GAAG,YAAY,CAAC,EAAE;AAE7D,QAAM,mBAAgD,CAAC;AACvD,QAAM,aAAuB,CAAC;AAE9B,aAAW,WAAW,UAAU;AAC9B,UAAM,aAAa,cAAc,KAAK,QAAQ,MAAM,IAAI,QAAQ,SAAS,KAAK,QAAQ,MAAM;AAC5F,UAAM,WAAW,iBAAiB,YAAY,UAAU,CAAC;AACzD,QAAI,CAAC,UAAU;AACb,iBAAW,KAAK,QAAQ,MAAM;AAC9B;AAAA,IACF;AACA,UAAM,QAAQ,gBAAgB,QAAQ,OAAO,WAAW;AACxD,qBAAiB,KAAK;AAAA,MACpB,YAAY,QAAQ;AAAA,MACpB;AAAA,MACA,GAAI,SAAS,OAAO,EAAE,MAAM,IAAI,CAAC;AAAA,IACnC,CAAC;AAAA,EACH;AAEA,SAAO,EAAE,UAAU,kBAAkB,WAAW;AAClD;AAgBO,SAAS,2BACd,UACU;AACV,SAAO,CAAC,GAAG,IAAI,IAAI,SAAS,IAAI,CAAC,YAAY,QAAQ,UAAU,CAAC,CAAC;AACnE;AAGO,SAAS,qBACd,WACA,aACwB;AACxB,MAAI,CAAC,WAAW,OAAQ,QAAO,CAAC;AAChC,SAAO,UAAU,IAAI,CAAC,cAAc;AAAA,IAClC,IAAI,SAAS;AAAA,IACb,OAAO,gBAAgB,SAAS,OAAO,WAAW,KAAK,SAAS;AAAA,IAChE,cAAc,SAAS;AAAA,IACvB,GAAI,SAAS,QAAQ,EAAE,OAAO,SAAS,MAAM,IAAI,CAAC;AAAA,EACpD,EAAE;AACJ;AAMO,SAAS,4BACd,QACe;AACf,QAAM,WAAW,OAAO,UAAU,YAAY,OAAO;AACrD,SAAO,OAAO,aAAa,YAAY,SAAS,SAAS,WAAW;AACtE;",
+  "names": ["resolved"]
+}

package/dist/modules/workflows/lib/task-sla.js

@@ -0,0 +1,357 @@
+import { StepInstance, UserTask, WorkflowInstance } from "../data/entities.js";
+import { parseDuration } from "./duration.js";
+import { resolveTaskBreachHandling } from "./breach-routing.js";
+import {
+  findAgentReviewConfig,
+  resolveAgentReviewBreachHandling,
+  INVOKE_AGENT_ACTIVITY_TYPE
+} from "./agent-review.js";
+import { findDefinitionForInstance } from "./find-definition.js";
+import { emitWorkflowsEvent } from "../events.js";
+import { createLogger } from "@open-mercato/shared/lib/logger";
+const logger = createLogger("workflows");
+const OPEN_TASK_STATUSES = ["PENDING", "IN_PROGRESS"];
+function computeTaskSlaSchedule(options) {
+  const { dueDate } = options;
+  if (!dueDate || Number.isNaN(dueDate.getTime())) return { entries: [], invalidOffsets: [] };
+  const nowMs = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  const deadlineMs = dueDate.getTime();
+  const entries = [];
+  const invalidOffsets = [];
+  for (const reminder of options.reminders ?? []) {
+    const offset = reminder?.offset;
+    if (typeof offset !== "string" || !offset.length) continue;
+    let offsetMs;
+    try {
+      offsetMs = parseDuration(offset);
+    } catch {
+      invalidOffsets.push(offset);
+      continue;
+    }
+    if (offsetMs <= 0) continue;
+    const remindAtMs = deadlineMs - offsetMs;
+    if (remindAtMs <= nowMs || remindAtMs >= deadlineMs) continue;
+    entries.push({
+      phase: "reminder",
+      fireAt: new Date(remindAtMs).toISOString(),
+      delayMs: remindAtMs - nowMs
+    });
+  }
+  entries.push({
+    phase: "breach",
+    fireAt: dueDate.toISOString(),
+    delayMs: Math.max(0, deadlineMs - nowMs)
+  });
+  entries.sort((left, right) => left.delayMs - right.delayMs);
+  return { entries, invalidOffsets };
+}
+async function scheduleUserTaskSla(options) {
+  const schedule = computeTaskSlaSchedule({
+    dueDate: options.dueDate,
+    reminders: options.reminders,
+    now: options.now
+  });
+  if (schedule.invalidOffsets.length) {
+    logger.warn("Task reminder offsets skipped because they are not valid durations", {
+      component: "task-sla",
+      taskId: options.userTaskId,
+      invalidOffsets: schedule.invalidOffsets
+    });
+  }
+  if (schedule.entries.length === 0) return [];
+  const deadlineAt = options.dueDate ? options.dueDate.toISOString() : null;
+  if (!deadlineAt) return [];
+  const jobIds = [];
+  try {
+    const { enqueueTaskSlaJob } = await import("./activity-executor.js");
+    for (const entry of schedule.entries) {
+      const jobId = await enqueueTaskSlaJob({
+        workflowInstanceId: options.workflowInstanceId,
+        stepInstanceId: options.stepInstanceId,
+        branchInstanceId: options.branchInstanceId ?? null,
+        userTaskId: options.userTaskId,
+        phase: entry.phase,
+        deadlineAt,
+        fireAt: entry.fireAt,
+        delayMs: entry.delayMs,
+        tenantId: options.tenantId,
+        organizationId: options.organizationId,
+        userId: options.userId
+      });
+      jobIds.push(jobId);
+    }
+  } catch (error) {
+    logger.error("Failed to schedule task SLA jobs", {
+      component: "task-sla",
+      taskId: options.userTaskId,
+      err: error
+    });
+  }
+  return jobIds;
+}
+async function runTaskSlaJob(em, container, options) {
+  const { tenantId, organizationId } = options;
+  const task = await em.findOne(UserTask, {
+    id: options.userTaskId,
+    tenantId,
+    organizationId
+  });
+  if (!task) return "noop";
+  if (!OPEN_TASK_STATUSES.includes(task.status)) return "noop";
+  const deadlineMs = Date.parse(options.deadlineAt);
+  if (Number.isNaN(deadlineMs)) return "noop";
+  if (options.phase === "reminder") {
+    if (task.escalatedAt) return "noop";
+    if (Date.now() >= deadlineMs) return "noop";
+    await logTaskSlaEvent(em, container, options, "USER_TASK_REMINDER_DUE", {
+      taskId: task.id,
+      taskName: task.taskName,
+      dueDate: options.deadlineAt
+    });
+    await emitTaskSlaEvent(em, "workflows.task.reminder_due", task, options);
+    return "reminded";
+  }
+  const now = /* @__PURE__ */ new Date();
+  const claimed = await em.nativeUpdate(
+    UserTask,
+    {
+      id: task.id,
+      tenantId,
+      organizationId,
+      status: { $in: [...OPEN_TASK_STATUSES] },
+      escalatedAt: null
+    },
+    { escalatedAt: now, updatedAt: now }
+  );
+  if (claimed === 0) return "noop";
+  task.escalatedAt = now;
+  task.updatedAt = now;
+  const handling = await applyBreachHandling(em, container, task, options, now);
+  await logTaskSlaEvent(em, container, options, "USER_TASK_DEADLINE_BREACHED", {
+    taskId: task.id,
+    taskName: task.taskName,
+    dueDate: options.deadlineAt,
+    breachedAt: now.toISOString(),
+    onBreach: handling.outcome,
+    ...handling.detail ?? {}
+  });
+  await emitTaskSlaEvent(em, "workflows.task.deadline_breached", task, options);
+  if (handling.outcome === "reassigned") {
+    await emitTaskSlaEvent(em, "workflows.task.assigned", task, options);
+  }
+  if (handling.resumeInstance) {
+    await resumeAfterBreachRoute(em, container, task, options, handling.resumeInstance);
+  }
+  return "breached";
+}
+function isInvokeAgentStepDef(step) {
+  return (step?.activities ?? []).some(
+    (activity) => activity?.activityType === INVOKE_AGENT_ACTIVITY_TYPE
+  );
+}
+async function applyBreachHandling(em, container, task, options, now) {
+  let resolution = { kind: "none" };
+  let stepId = null;
+  let instance = null;
+  try {
+    const stepInstance = await em.findOne(StepInstance, {
+      id: options.stepInstanceId,
+      tenantId: options.tenantId,
+      organizationId: options.organizationId
+    });
+    stepId = stepInstance?.stepId ?? null;
+    instance = await em.findOne(WorkflowInstance, {
+      id: options.workflowInstanceId,
+      tenantId: options.tenantId,
+      organizationId: options.organizationId
+    });
+    if (stepId && instance) {
+      const definition = await findDefinitionForInstance(em, instance);
+      const stepDef = (definition?.definition?.steps ?? []).find(
+        (step) => step.stepId === stepId
+      );
+      resolution = isInvokeAgentStepDef(stepDef) ? resolveAgentReviewBreachHandling(findAgentReviewConfig(stepDef)?.onBreach ?? null) : resolveTaskBreachHandling(
+        definition?.definition ?? null,
+        stepId,
+        stepDef?.userTaskConfig?.onBreach ?? null
+      );
+    }
+  } catch (error) {
+    logger.error("Failed to resolve breach handling; falling back to notify-only", {
+      component: "task-sla",
+      taskId: task.id,
+      err: error
+    });
+    return { outcome: "none" };
+  }
+  if (resolution.kind === "notify") return { outcome: "notified" };
+  if (resolution.kind === "attention") {
+    if (!instance) return { outcome: "none" };
+    await markInstanceForAttention(em, instance, stepId, task, now);
+    return { outcome: "attention", detail: { stepId } };
+  }
+  if (resolution.kind === "reassign") {
+    task.assignedTo = resolution.assignedTo;
+    task.assignedToRoles = resolution.assignedToRoles;
+    task.claimedBy = null;
+    task.claimedAt = null;
+    task.status = "PENDING";
+    task.escalatedTo = resolution.assignedTo ?? resolution.assignedToRoles?.[0] ?? null;
+    task.reassignedAt = now;
+    task.reassignReason = "sla_breach";
+    task.updatedAt = now;
+    await em.flush();
+    return {
+      outcome: "reassigned",
+      detail: {
+        reassignedTo: resolution.assignedTo,
+        reassignedToRoles: resolution.assignedToRoles
+      }
+    };
+  }
+  if (resolution.kind === "route") {
+    const toStepId = resolution.transition.toStepId;
+    if (!stepId || !toStepId) return { outcome: "none" };
+    if (options.branchInstanceId) {
+      return { outcome: "route_skipped_branch", detail: { transitionId: resolution.transition.transitionId } };
+    }
+    task.status = "ESCALATED";
+    task.updatedAt = now;
+    await em.flush();
+    return {
+      outcome: "routed",
+      detail: { transitionId: resolution.transition.transitionId, toStepId },
+      resumeInstance: { stepId, toStepId, transitionId: resolution.transition.transitionId }
+    };
+  }
+  return { outcome: "none" };
+}
+async function markInstanceForAttention(em, instance, stepId, task, now) {
+  instance.metadata = {
+    ...instance.metadata || {},
+    attention: {
+      reason: "DISPOSITION_SLA_BREACH",
+      ...stepId ? { stepId } : {},
+      at: now.toISOString()
+    }
+  };
+  instance.updatedAt = now;
+  await em.flush();
+  logger.warn("Agent disposition deadline passed; run marked for attention", {
+    component: "task-sla",
+    taskId: task.id,
+    workflowInstanceId: instance.id,
+    stepId
+  });
+}
+async function resumeAfterBreachRoute(em, container, task, options, route) {
+  try {
+    const instance = await em.findOne(WorkflowInstance, {
+      id: options.workflowInstanceId,
+      tenantId: options.tenantId,
+      organizationId: options.organizationId
+    });
+    if (!instance) return;
+    const stepHandler = container.resolve("stepHandler");
+    const transitionHandler = container.resolve("transitionHandler");
+    const workflowExecutor = container.resolve("workflowExecutor");
+    const stepInstance = await em.findOne(StepInstance, {
+      id: options.stepInstanceId,
+      status: "ACTIVE"
+    });
+    if (stepInstance) {
+      await stepHandler.exitStep(em, stepInstance, {
+        userTaskId: task.id,
+        slaBreached: true
+      });
+    }
+    const transitionResult = await transitionHandler.executeTransition(
+      em,
+      container,
+      instance,
+      route.stepId,
+      route.toStepId,
+      {
+        workflowContext: instance.context,
+        userId: options.userId,
+        transitionId: route.transitionId
+      }
+    );
+    if (!transitionResult.success) {
+      logger.error("SLA-breach transition failed", {
+        component: "task-sla",
+        taskId: task.id,
+        err: transitionResult.error
+      });
+      return;
+    }
+    await workflowExecutor.executeWorkflow(em, container, instance.id, { userId: options.userId });
+  } catch (error) {
+    logger.error("Failed to follow the SLA-breach route", {
+      component: "task-sla",
+      taskId: task.id,
+      err: error
+    });
+  }
+}
+async function logTaskSlaEvent(em, container, options, eventType, eventData) {
+  try {
+    const eventLogger = container.resolve("eventLogger");
+    await eventLogger.logWorkflowEvent(em, {
+      workflowInstanceId: options.workflowInstanceId,
+      stepInstanceId: options.stepInstanceId,
+      ...options.branchInstanceId ? { branchInstanceId: options.branchInstanceId } : {},
+      eventType,
+      eventData,
+      userId: options.userId,
+      tenantId: options.tenantId,
+      organizationId: options.organizationId
+    });
+  } catch (error) {
+    logger.error("Failed to log task SLA workflow event", {
+      component: "task-sla",
+      taskId: options.userTaskId,
+      eventType,
+      err: error
+    });
+  }
+}
+async function emitTaskSlaEvent(em, eventId, task, options) {
+  try {
+    const instance = await em.findOne(WorkflowInstance, {
+      id: options.workflowInstanceId,
+      tenantId: options.tenantId,
+      organizationId: options.organizationId
+    });
+    await emitWorkflowsEvent(
+      eventId,
+      {
+        taskId: task.id,
+        taskName: task.taskName,
+        workflowInstanceId: options.workflowInstanceId,
+        workflowId: instance?.workflowId ?? null,
+        workflowName: instance?.workflowId ?? "",
+        assignedUserId: task.claimedBy ?? task.assignedTo ?? null,
+        assignedToRoles: task.assignedToRoles ?? null,
+        dueDate: options.deadlineAt,
+        entityBindings: task.entityBindings ?? null,
+        tenantId: options.tenantId,
+        organizationId: options.organizationId
+      },
+      { persistent: true }
+    );
+  } catch (error) {
+    logger.error("Failed to emit task SLA event", {
+      component: "task-sla",
+      taskId: task.id,
+      eventId,
+      err: error
+    });
+  }
+}
+export {
+  computeTaskSlaSchedule,
+  runTaskSlaJob,
+  scheduleUserTaskSla
+};
+//# sourceMappingURL=task-sla.js.map