@open-mercato/core 0.10.1-develop.7741.1.61a2652671 → 0.10.1-develop.7749.1.ea3edf75e3

package/src/modules/workflows/lib/condition-handler.ts

@@ -106,6 +106,21 @@ export function resolveMaxConditionAttempts(): number {
   return parsed
 }
 
+/**
+ * The attempt cap one waiter actually gets: the configured floor, raised to the
+ * number of polls its own timeout needs (`timeoutMs / pollIntervalMs`, plus
+ * the entry poll). A fixed 1000 would force a 90-day wait polled hourly to
+ * time out after ~42 days. The deadline still ends the wait first; this only
+ * bounds a loop whose deadline arithmetic went wrong.
+ */
+export function resolveConditionAttemptCap(
+  config: Pick<WaitForConditionConfig, 'timeoutMs' | 'pollIntervalMs'>
+): number {
+  const floor = resolveMaxConditionAttempts()
+  if (!(config.timeoutMs > 0) || !(config.pollIntervalMs > 0)) return floor
+  return Math.max(floor, Math.ceil(config.timeoutMs / config.pollIntervalMs) + 1)
+}
+
 /**
  * Read and normalise a WAIT_FOR_CONDITION step's config. Fails closed: the
  * predicate and the timeout are both mandatory, and the poll interval is
@@ -499,7 +514,7 @@ export async function evaluateWaitCondition(
 
   const deadlineMs = Date.parse(options.deadlineAt)
   const deadlinePassed = Number.isFinite(deadlineMs) ? nowMs >= deadlineMs : true
-  const attemptCapReached = attempts >= resolveMaxConditionAttempts()
+  const attemptCapReached = attempts >= resolveConditionAttemptCap(waiter.config)
 
   if (deadlinePassed || attemptCapReached) {
     const eventLogger = container.resolve<typeof eventLoggerModule>('eventLogger')

package/src/modules/workflows/lib/duration.ts

@@ -147,6 +147,31 @@ export function calculateDueDate(duration: string, from: Date = new Date()): Dat
   return new Date(from.getTime() + parseDuration(duration))
 }
 
+/**
+ * Largest delay Node's `setTimeout` honours (a signed 32-bit millisecond count,
+ * ~24.86 days). A longer delay is not rejected — it fires after 1 ms with only a
+ * `TimeoutOverflowWarning` — so an in-process wait must refuse it explicitly.
+ */
+export const MAX_TIMER_DELAY_MS = 2_147_483_647
+
+/**
+ * A WAIT longer than this is not slept inside the executing request: when it is
+ * the last activity of its transition it is handed to the activity queue (the
+ * path an `async: true` WAIT already takes). One minute keeps the short pauses
+ * people use for pacing inline while anything that would hold a request or a
+ * worker slot open for minutes becomes durable.
+ */
+export const MAX_INLINE_WAIT_MS = 60_000
+
+export function assertInProcessWaitDelay(delayMs: number): number {
+  if (delayMs > MAX_TIMER_DELAY_MS) {
+    throw new Error(
+      `WAIT activity: a ${delayMs}ms delay cannot be slept in-process (limit ${MAX_TIMER_DELAY_MS}ms); make it the last activity of its transition, mark it async, or use a WAIT_FOR_TIMER step`
+    )
+  }
+  return delayMs
+}
+
 export function calculateWaitDelayMs(config: { duration?: string; until?: string }): number {
   if (config.until) {
     const targetDate = new Date(config.until)

package/src/modules/workflows/lib/step-handler.ts

@@ -222,6 +222,21 @@ async function emitStepMilestone(em: EntityManager, stepInstance: StepInstance):
   }
 }
 
+/**
+ * `step_instances.execution_time_ms` is a Postgres `integer`, so a step that
+ * lasted 2^31 ms (~24.86 days) or longer cannot be stored there — the flush
+ * that completes the step would throw after its task already committed,
+ * stranding the run. Such a duration persists as `null` (every reader already
+ * falls back to `exitedAt - enteredAt`); the exact value still travels on the
+ * `STEP_EXITED` event, whose payload is jsonb.
+ */
+export const MAX_PERSISTED_EXECUTION_TIME_MS = 2_147_483_647
+
+export function toPersistableExecutionTimeMs(executionTimeMs: number | null): number | null {
+  if (executionTimeMs === null || !Number.isFinite(executionTimeMs)) return null
+  return Math.abs(executionTimeMs) > MAX_PERSISTED_EXECUTION_TIME_MS ? null : executionTimeMs
+}
+
 export async function exitStep(
   em: EntityManager,
   stepInstance: StepInstance,
@@ -239,7 +254,7 @@ export async function exitStep(
   stepInstance.status = 'COMPLETED'
   stepInstance.outputData = outputData || null
   stepInstance.exitedAt = now
-  stepInstance.executionTimeMs = executionTimeMs
+  stepInstance.executionTimeMs = toPersistableExecutionTimeMs(executionTimeMs)
   stepInstance.updatedAt = now
 
   await em.flush()

package/src/modules/workflows/lib/task-quick-action.ts

@@ -43,6 +43,24 @@ export const TASK_QUICK_ACTION_VIEW_ID = 'view'
 
 export const TASK_DEEP_LINK_HREF = '/backend/tasks/{sourceEntityId}'
 
+/** Feature the clicking user must hold to complete a task from its notification. */
+export const TASK_COMPLETE_REQUIRED_FEATURE = 'workflows.tasks.complete'
+
+/**
+ * The one-click completion button. Shared by {@link buildTaskQuickActions} and the
+ * `workflows.task.assigned` type declaration, so the stored action id and command id always
+ * match what the notifications module allows to dispatch.
+ */
+export function buildTaskQuickCompleteAction(): NotificationTypeAction {
+  return {
+    id: TASK_QUICK_ACTION_COMPLETE_ID,
+    labelKey: 'workflows.notifications.task.actions.complete',
+    variant: 'default',
+    icon: 'check',
+    commandId: TASK_COMPLETE_COMMAND_ID,
+  }
+}
+
 export interface TaskQuickActionInput {
   /** Decision buttons resolved for this task. */
   decisions?: { id: string }[] | null
@@ -90,16 +108,7 @@ export function buildTaskQuickActions(input: TaskQuickActionInput): Notification
 
   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,
-    },
-  ]
+  return [viewAction, buildTaskQuickCompleteAction()]
 }
 
 /**

package/src/modules/workflows/lib/transition-handler.ts

@@ -522,7 +522,8 @@ export async function executeTransitionForToken(
         em,
         container,
         transition.activities as ActivityDefinition[],
-        activityContext
+        activityContext,
+        { queueLongInlineWaits: true }
       )
 
       activityResults.push(...results)

package/src/modules/workflows/notifications.ts

@@ -1,4 +1,5 @@
 import type { NotificationTypeDefinition } from '@open-mercato/shared/modules/notifications/types'
+import { buildTaskQuickCompleteAction, TASK_COMPLETE_REQUIRED_FEATURE } from './lib/task-quick-action'
 
 const taskDeepLink = '/backend/tasks/{sourceEntityId}'
 
@@ -21,6 +22,9 @@ export const notificationTypes: NotificationTypeDefinition[] = [
     icon: 'clipboard-list',
     severity: 'info',
     actions: [viewTaskAction],
+    optionalActions: [
+      { ...buildTaskQuickCompleteAction(), requiredFeatures: [TASK_COMPLETE_REQUIRED_FEATURE] },
+    ],
     linkHref: taskDeepLink,
     expiresAfterHours: 168, // 7 days
   },