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

package/dist/modules/workflows/lib/run-execution.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/run-execution.ts"],
+  "sourcesContent": ["/**\n * Run execution overlay (spec \u00A78.3) \u2014 PURE.\n *\n * Answers one question for every surface that paints a finished or in-flight\n * run: which steps ran, how long each took, which routes were taken, and where\n * the instance is now. The instance detail page, the run Gantt and the Studio's\n * \"Show last run\" overlay all read this, so they can never disagree about what\n * a run did.\n *\n * No React, no ORM, no DI, no registry imports \u2014 the same rule\n * `lib/error-routing.ts` and `lib/context-ledger.ts` follow.\n *\n * Two inputs, deliberately ranked:\n *\n * - `StepInstance` rows are AUTHORITATIVE for step state. One row per step\n *   execution carries the status, both timestamps, the measured duration and\n *   the attempt count with no inference. There are also far fewer of them than\n *   there are events, which matters: the detail page reads the newest 100\n *   events, so on a long run the STEP_ENTERED of an early step falls off the\n *   page and an event-only derivation paints a completed step as never-run.\n * - `WorkflowEvent` rows are the fallback for step state and the ONLY source\n *   for the taken path \u2014 a transition leaves no row of its own.\n */\n\nimport type { StepRunStatus } from './status-colors'\n\n/** Step-status vocabulary written by the engine, plus the legacy PascalCase spellings. */\nconst STEP_ENTERED_EVENT_TYPES = new Set(['STEP_ENTERED', 'StepEntered'])\nconst STEP_COMPLETED_EVENT_TYPES = new Set(['STEP_COMPLETED', 'STEP_EXITED', 'StepExited'])\nconst STEP_FAILED_EVENT_TYPES = new Set(['STEP_FAILED', 'StepFailed'])\nconst STEP_SKIPPED_EVENT_TYPES = new Set(['STEP_SKIPPED', 'StepSkipped'])\nconst TRANSITION_EXECUTED_EVENT_TYPES = new Set(['TRANSITION_EXECUTED', 'TransitionExecuted'])\n\n/**\n * Events that RESOLVE a park. A step can park more than once in a run (a loop,\n * a retry, a rerun-from-step), so evidence is cleared as soon as the thing it\n * described came back \u2014 otherwise a step that waited for a signal on its first\n * pass keeps claiming to wait for it on its second.\n */\nconst WAIT_RESOLVED_EVENT_TYPES = new Set([\n  'ACTIVITY_COMPLETED',\n  'ACTIVITY_FAILED',\n  'SIGNAL_RECEIVED',\n  'TIMER_FIRED',\n  'CONDITION_MET',\n  'CONDITION_TIMED_OUT',\n  'USER_TASK_COMPLETED',\n  'PARALLEL_JOIN_COMPLETED',\n])\n\nconst BRANCH_SETTLED_EVENT_TYPES = new Set([\n  'PARALLEL_BRANCH_COMPLETED',\n  'PARALLEL_BRANCH_FAILED',\n  'PARALLEL_BRANCH_CANCELLED',\n])\n\nexport type RunEventInput = {\n  eventType: string\n  eventData?: Record<string, unknown> | null\n  occurredAt: string | Date\n  /**\n   * The engine stamps every step-scoped event with the `StepInstance` row it\n   * belongs to, but only some of them repeat the definition `stepId` inside\n   * `eventData`. Carrying the id here is what lets the park events\n   * (`SIGNAL_AWAITING`, `TIMER_AWAITING`, `USER_TASK_CREATED`, \u2026) be attributed\n   * to a step at all \u2014 they name the row, never the step.\n   */\n  stepInstanceId?: string | null\n}\n\nexport type RunStepInstanceInput = {\n  id?: string\n  stepId: string\n  stepName?: string\n  stepType?: string\n  status: string\n  branchInstanceId?: string | null\n  inputData?: unknown\n  outputData?: unknown\n  errorData?: unknown\n  enteredAt?: string | Date | null\n  exitedAt?: string | Date | null\n  executionTimeMs?: number | null\n  retryCount?: number | null\n}\n\nexport type StepRunState = {\n  stepId: string\n  status: StepRunStatus\n  startedAt: Date | null\n  completedAt: Date | null\n  /** Measured by the engine when available, otherwise derived from the timestamps. */\n  durationMs: number | null\n  /** 1 for a step that ran once; `retryCount + 1` when the engine recorded retries. */\n  attempts: number\n}\n\nexport type TakenRoute = {\n  transitionId: string | null\n  fromStepId: string\n  toStepId: string\n  at: Date\n}\n\n/**\n * What a non-terminal step is doing or waiting for, read off the events the\n * engine ALREADY writes when it parks (spec \u00A7Part 2). Nothing here is a new\n * column and nothing here is a new event: `SIGNAL_AWAITING`, `TIMER_AWAITING`,\n * `CONDITION_AWAITING`, `USER_TASK_CREATED`, `ACTIVITY_QUEUED` and\n * `PARALLEL_FORK_OPENED` are all durable rows today.\n *\n * `StepInstance.outputData` \u2014 which carries the same facts on the return value\n * of `enterStep` \u2014 is deliberately NOT read: `exitStep` writes it on the\n * COMPLETED path only, so on a parked step it is null. The events are the only\n * place the park survives.\n */\nexport type StepWaitEvidence =\n  | { kind: 'asyncActivity'; activityName: string | null }\n  /**\n   * The agent job is on the dedicated `workflow-invoke-agent` queue and the step\n   * is parked on the proposal-ready signal WAITING FOR THE AGENT ITSELF.\n   * `INVOKE_AGENT` is not async-capable in the registry's sense\n   * (`async: { capable: false, reason: 'parksOnDedicatedQueue' }`), so it never\n   * logs `ACTIVITY_QUEUED` \u2014 the park event is the only trace, and its absence\n   * of a `proposalId` is what says the agent has not answered yet.\n   */\n  | { kind: 'agentRunning'; agentId: string | null }\n  /**\n   * The agent answered and its proposal was routed to a human.\n   * `lib/agent-disposition-task.ts` writes a real `UserTask` and logs\n   * `USER_TASK_CREATED` carrying the `proposalId` against the SAME step\n   * instance \u2014 which is the only durable thing that distinguishes \"the agent is\n   * still running\" from \"a person has not decided yet\". The invoke-agent\n   * worker's own `user_task` branch logs nothing.\n   */\n  | { kind: 'agentDisposition'; proposalId: string | null }\n  | { kind: 'subWorkflow'; childInstanceId: string | null }\n  | { kind: 'signal'; signalName: string | null }\n  | { kind: 'timer'; fireAt: Date | null }\n  | { kind: 'condition'; deadlineAt: Date | null }\n  | {\n      kind: 'userTask'\n      /**\n       * The authored ROLE QUEUE, which is definition data every viewer of the\n       * run already sees on the canvas. The individual assignee is deliberately\n       * absent \u2014 see `hasAssignee`.\n       */\n      roleQueue: string | null\n      /**\n       * Whether an individual was resolved. The id itself is NOT carried: the\n       * \u00A76.4 visibility model decides who may see a task's owner, and this line\n       * must not become a way around it. The run APIs expose an opaque user id\n       * and no display name, so there is nothing honest to render either way.\n       */\n      hasAssignee: boolean\n    }\n  | { kind: 'fork'; branchTotal: number; branchesSettled: number }\n\n/**\n * The engine-owned `metadata.attention` marker (the `failureQueue` directive\n * and the agent-review breach escalation both write it). Instance-level, so it\n * describes the step the run is parked on.\n */\nexport type RunAttention = { reason: string | null }\n\nexport type RunExecution = {\n  stepStates: Map<string, StepRunState>\n  routes: TakenRoute[]\n  takenTransitionIds: Set<string>\n  /** `from->to` pairs, so a route whose transition id was never recorded still paints. */\n  takenStepPairs: Set<string>\n  /**\n   * Carried on the overlay so `resolveNodeRunStatus` can answer the START/END\n   * conventions without every caller having to remember to pass them. A caller\n   * that forgets is not obviously wrong \u2014 it just silently paints the END node\n   * as never-reached on a completed run.\n   */\n  currentStepId: string | null\n  instanceStatus: string | null\n  /** Per-step park evidence, keyed by definition `stepId`. */\n  waits: Map<string, StepWaitEvidence>\n  attention: RunAttention | null\n}\n\nexport type RunExecutionInput = {\n  events?: readonly RunEventInput[]\n  stepInstances?: readonly RunStepInstanceInput[]\n  currentStepId?: string | null\n  instanceStatus?: string | null\n  /** `instance.metadata.attention` verbatim; anything unshaped is ignored. */\n  attention?: unknown\n}\n\nfunction toDate(value: string | Date | null | undefined): Date | null {\n  if (!value) return null\n  const parsed = value instanceof Date ? value : new Date(value)\n  return Number.isNaN(parsed.getTime()) ? null : parsed\n}\n\nfunction readStringField(data: Record<string, unknown> | null | undefined, key: string): string | null {\n  const value = data?.[key]\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\nexport function stepPairKey(fromStepId: string, toStepId: string): string {\n  return `${fromStepId}->${toStepId}`\n}\n\n/** Map the persisted `StepInstance.status` onto the canvas run vocabulary. */\nexport function stepInstanceStatusToRunStatus(status: string): StepRunStatus {\n  switch (status) {\n    case 'COMPLETED':\n      return 'completed'\n    case 'FAILED':\n      return 'failed'\n    case 'SKIPPED':\n      return 'skipped'\n    case 'ACTIVE':\n      return 'active'\n    case 'CANCELLED':\n      return 'skipped'\n    default:\n      return 'pending'\n  }\n}\n\n/**\n * A step can execute more than once in one run \u2014 a loop, a retry after a\n * failure route, or a rerun-from-step. The LATEST execution is the one the\n * canvas paints, so states are merged rather than overwritten blindly.\n */\nfunction isNewerExecution(candidate: StepRunState, existing: StepRunState): boolean {\n  const candidateAt = candidate.completedAt ?? candidate.startedAt\n  const existingAt = existing.completedAt ?? existing.startedAt\n  if (!existingAt) return true\n  if (!candidateAt) return false\n  return candidateAt.getTime() >= existingAt.getTime()\n}\n\nfunction stateFromStepInstance(stepInstance: RunStepInstanceInput): StepRunState {\n  const startedAt = toDate(stepInstance.enteredAt)\n  const completedAt = toDate(stepInstance.exitedAt)\n  const measured =\n    typeof stepInstance.executionTimeMs === 'number' && Number.isFinite(stepInstance.executionTimeMs)\n      ? stepInstance.executionTimeMs\n      : null\n  const derived = startedAt && completedAt ? completedAt.getTime() - startedAt.getTime() : null\n  const retries =\n    typeof stepInstance.retryCount === 'number' && Number.isFinite(stepInstance.retryCount)\n      ? Math.max(stepInstance.retryCount, 0)\n      : 0\n  return {\n    stepId: stepInstance.stepId,\n    status: stepInstanceStatusToRunStatus(stepInstance.status),\n    startedAt,\n    completedAt,\n    durationMs: measured ?? derived,\n    attempts: retries + 1,\n  }\n}\n\nfunction mergeState(target: Map<string, StepRunState>, candidate: StepRunState): void {\n  const existing = target.get(candidate.stepId)\n  if (!existing || isNewerExecution(candidate, existing)) {\n    target.set(candidate.stepId, candidate)\n  }\n}\n\nfunction applyEvent(target: Map<string, StepRunState>, event: RunEventInput): void {\n  const stepId = readStringField(event.eventData, 'stepId')\n  if (!stepId) return\n  const occurredAt = toDate(event.occurredAt)\n  const existing = target.get(stepId)\n  const base: StepRunState = existing ?? {\n    stepId,\n    status: 'pending',\n    startedAt: null,\n    completedAt: null,\n    durationMs: null,\n    attempts: 1,\n  }\n\n  if (STEP_ENTERED_EVENT_TYPES.has(event.eventType)) {\n    // A re-entry starts a fresh execution: the previous terminal timestamps do\n    // not describe the attempt now running.\n    target.set(stepId, {\n      ...base,\n      startedAt: occurredAt,\n      completedAt: null,\n      durationMs: null,\n      status: 'active',\n    })\n    return\n  }\n\n  const terminalStatus: StepRunStatus | null = STEP_COMPLETED_EVENT_TYPES.has(event.eventType)\n    ? 'completed'\n    : STEP_FAILED_EVENT_TYPES.has(event.eventType)\n      ? 'failed'\n      : STEP_SKIPPED_EVENT_TYPES.has(event.eventType)\n        ? 'skipped'\n        : null\n  if (!terminalStatus) return\n\n  const startedAt = base.startedAt\n  target.set(stepId, {\n    ...base,\n    status: terminalStatus,\n    completedAt: occurredAt,\n    durationMs: startedAt && occurredAt ? occurredAt.getTime() - startedAt.getTime() : base.durationMs,\n  })\n}\n\n/**\n * Paint the step the instance is parked on from the LIVE instance status: a\n * failed instance shows its current step red, a paused/waiting one yellow, an\n * otherwise-running one blue. Never overrides a step that already reached a\n * terminal state of its own.\n */\nfunction applyLiveInstanceStatus(\n  stepStates: Map<string, StepRunState>,\n  currentStepId: string | null | undefined,\n  instanceStatus: string | null | undefined\n): void {\n  if (!currentStepId) return\n  const existing = stepStates.get(currentStepId)\n  if (existing && (existing.status === 'completed' || existing.status === 'failed' || existing.status === 'skipped')) {\n    return\n  }\n  const liveStatus: StepRunStatus =\n    instanceStatus === 'FAILED'\n      ? 'failed'\n      : instanceStatus === 'PAUSED' || instanceStatus === 'WAITING_FOR_ACTIVITIES'\n        ? 'paused'\n        : 'active'\n  stepStates.set(currentStepId, {\n    stepId: currentStepId,\n    status: liveStatus,\n    startedAt: existing?.startedAt ?? null,\n    completedAt: null,\n    durationMs: existing?.durationMs ?? null,\n    attempts: existing?.attempts ?? 1,\n  })\n}\n\nfunction readBooleanish(data: Record<string, unknown> | null | undefined, key: string): boolean {\n  const value = data?.[key]\n  if (Array.isArray(value)) return value.length > 0\n  return typeof value === 'string' ? value.length > 0 : Boolean(value)\n}\n\nfunction readRoleQueue(data: Record<string, unknown> | null | undefined): string | null {\n  const value = data?.assignedToRoles\n  if (Array.isArray(value)) {\n    const named = value.filter((entry): entry is string => typeof entry === 'string' && entry.length > 0)\n    return named.length > 0 ? named.join(', ') : null\n  }\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\n/**\n * Turn one park event into evidence. Returns `null` for anything that is not a\n * park, so the caller can leave whatever it already had in place.\n */\nfunction waitEvidenceFromEvent(event: RunEventInput): StepWaitEvidence | null {\n  const data = event.eventData ?? null\n  switch (event.eventType) {\n    case 'ACTIVITY_QUEUED':\n      return {\n        kind: 'asyncActivity',\n        activityName: readStringField(data, 'activityName') ?? readStringField(data, 'activityType'),\n      }\n    case 'SIGNAL_AWAITING': {\n      // One event type, three genuinely different situations. The engine\n      // distinguishes them with `reason` (INVOKE_AGENT / SUB_WORKFLOW) plus the\n      // ids it carries, and the presentation states differ, so they cannot be\n      // collapsed into \"waiting for a signal\".\n      const reason = readStringField(data, 'reason')\n      const childInstanceId = readStringField(data, 'childInstanceId')\n      if (reason === 'SUB_WORKFLOW' || childInstanceId) {\n        return { kind: 'subWorkflow', childInstanceId }\n      }\n      const proposalId = readStringField(data, 'proposalId')\n      if (reason === 'INVOKE_AGENT') {\n        // A `proposalId` at park time means the agent already ran inline (the\n        // parallel-branch fallback path); its absence \u2014 the instance-level path \u2014\n        // means the job was only just enqueued.\n        return proposalId\n          ? { kind: 'agentDisposition', proposalId }\n          : { kind: 'agentRunning', agentId: readStringField(data, 'agentId') }\n      }\n      return { kind: 'signal', signalName: readStringField(data, 'signalName') }\n    }\n    case 'TIMER_AWAITING':\n      return { kind: 'timer', fireAt: toDate(readStringField(data, 'fireAt')) }\n    case 'CONDITION_AWAITING':\n      return { kind: 'condition', deadlineAt: toDate(readStringField(data, 'deadlineAt')) }\n    case 'USER_TASK_CREATED': {\n      // The agent-disposition review is a REAL user task, so it arrives here \u2014\n      // and its `proposalId` is what tells the two apart.\n      const proposalId = readStringField(data, 'proposalId')\n      if (proposalId) return { kind: 'agentDisposition', proposalId }\n      return {\n        kind: 'userTask',\n        roleQueue: readRoleQueue(data),\n        hasAssignee: readBooleanish(data, 'assignedTo'),\n      }\n    }\n    default:\n      return null\n  }\n}\n\n/**\n * Fork progress is a TALLY over events, not a read of `WorkflowBranchInstance`:\n * the branch rows have no read surface, but `PARALLEL_FORK_OPENED` names every\n * branch key and each branch logs its own settle event. Counting them answers\n * \"n of m branches still running\" from evidence that is already durable.\n */\ntype ForkTally = { stepId: string; branchKeys: Set<string>; settled: Set<string> }\n\nexport function deriveRunExecution(input: RunExecutionInput): RunExecution {\n  const stepStates = new Map<string, StepRunState>()\n  const routes: TakenRoute[] = []\n  const takenTransitionIds = new Set<string>()\n  const takenStepPairs = new Set<string>()\n  const waits = new Map<string, StepWaitEvidence>()\n  const stepIdByStepInstanceId = new Map<string, string>()\n  let forkTally: ForkTally | null = null\n  // Steps whose LATEST attempt only \"completed\" by advancing down an error /\n  // guardrailBlocked outcome route (\u00A77.2) or a \u00A75.9 error route. The engine\n  // records such a step as COMPLETED (it advanced), but its agent/activity did\n  // not succeed \u2014 so the run view must not paint it a green \"done\". Re-entry\n  // clears the flag, so a successful re-run (retry) shows green again.\n  const erroredRoutedSteps = new Set<string>()\n\n  for (const stepInstance of input.stepInstances ?? []) {\n    if (stepInstance.id) stepIdByStepInstanceId.set(stepInstance.id, stepInstance.stepId)\n  }\n\n  // Events come back newest-first from the API; replay them oldest-first so a\n  // later terminal event wins over an earlier entry for the same step.\n  const orderedEvents = [...(input.events ?? [])].sort((left, right) => {\n    const leftAt = toDate(left.occurredAt)?.getTime() ?? 0\n    const rightAt = toDate(right.occurredAt)?.getTime() ?? 0\n    return leftAt - rightAt\n  })\n\n  for (const event of orderedEvents) {\n    applyEvent(stepStates, event)\n\n    const eventStepId =\n      readStringField(event.eventData, 'stepId')\n      ?? (event.stepInstanceId ? stepIdByStepInstanceId.get(event.stepInstanceId) ?? null : null)\n\n    if (eventStepId) {\n      // A re-entry starts a fresh attempt, so anything the previous one parked\n      // on no longer describes this step.\n      if (STEP_ENTERED_EVENT_TYPES.has(event.eventType) || WAIT_RESOLVED_EVENT_TYPES.has(event.eventType)) {\n        waits.delete(eventStepId)\n      }\n      const evidence = waitEvidenceFromEvent(event)\n      if (evidence) waits.set(eventStepId, evidence)\n    }\n\n    // Track error/guardrailBlocked routing so a routed-but-failed step is not\n    // painted as a clean completion below. A fresh attempt (STEP_ENTERED) clears\n    // it, so only the latest attempt's outcome counts.\n    if (eventStepId && STEP_ENTERED_EVENT_TYPES.has(event.eventType)) {\n      erroredRoutedSteps.delete(eventStepId)\n    } else if (event.eventType === 'OUTCOME_ROUTED') {\n      const outcome = readStringField(event.eventData, 'outcome')\n      const routedStepId = readStringField(event.eventData, 'stepId')\n      if (routedStepId && (outcome === 'error' || outcome === 'guardrailBlocked')) {\n        erroredRoutedSteps.add(routedStepId)\n      }\n    } else if (event.eventType === 'ERROR_ROUTED') {\n      const failedStepId = readStringField(event.eventData, 'failedStepId')\n      if (failedStepId) erroredRoutedSteps.add(failedStepId)\n    }\n\n    if (event.eventType === 'PARALLEL_FORK_OPENED') {\n      const forkStepId = readStringField(event.eventData, 'forkStepId')\n      const branchKeys = event.eventData?.branchKeys\n      if (forkStepId && Array.isArray(branchKeys)) {\n        forkTally = {\n          stepId: forkStepId,\n          branchKeys: new Set(branchKeys.filter((key): key is string => typeof key === 'string')),\n          settled: new Set<string>(),\n        }\n      }\n    } else if (BRANCH_SETTLED_EVENT_TYPES.has(event.eventType) && forkTally) {\n      const branchKey = readStringField(event.eventData, 'branchKey')\n      if (branchKey && forkTally.branchKeys.has(branchKey)) forkTally.settled.add(branchKey)\n    } else if (event.eventType === 'PARALLEL_JOIN_COMPLETED' && forkTally) {\n      waits.delete(forkTally.stepId)\n      forkTally = null\n    }\n\n    if (!TRANSITION_EXECUTED_EVENT_TYPES.has(event.eventType)) continue\n    const fromStepId = readStringField(event.eventData, 'fromStepId')\n    const toStepId = readStringField(event.eventData, 'toStepId')\n    if (!fromStepId || !toStepId) continue\n    const transitionId = readStringField(event.eventData, 'transitionId')\n    routes.push({\n      transitionId,\n      fromStepId,\n      toStepId,\n      at: toDate(event.occurredAt) ?? new Date(0),\n    })\n    if (transitionId) takenTransitionIds.add(transitionId)\n    takenStepPairs.add(stepPairKey(fromStepId, toStepId))\n  }\n\n  // Step instances are authoritative and overwrite whatever the events implied.\n  for (const stepInstance of input.stepInstances ?? []) {\n    mergeState(stepStates, stateFromStepInstance(stepInstance))\n  }\n\n  // A step whose latest attempt exited only by routing an error/guardrailBlocked\n  // outcome (or a \u00A75.9 error route) is recorded COMPLETED by the engine, but its\n  // work failed \u2014 repaint it errored so the run view never shows a green \"done\"\n  // for a step whose agent/activity failed. Runs AFTER the authoritative pass;\n  // only flips a currently-completed step (a live/failed one already tells the\n  // truth), and a successful re-run cleared the flag so it stays green.\n  for (const stepId of erroredRoutedSteps) {\n    const existing = stepStates.get(stepId)\n    if (existing && existing.status === 'completed') {\n      stepStates.set(stepId, { ...existing, status: 'failed' })\n    }\n  }\n\n  applyLiveInstanceStatus(stepStates, input.currentStepId, input.instanceStatus)\n\n  if (forkTally && forkTally.branchKeys.size > forkTally.settled.size) {\n    waits.set(forkTally.stepId, {\n      kind: 'fork',\n      branchTotal: forkTally.branchKeys.size,\n      branchesSettled: forkTally.settled.size,\n    })\n  }\n\n  return {\n    stepStates,\n    routes,\n    takenTransitionIds,\n    takenStepPairs,\n    currentStepId: input.currentStepId ?? null,\n    instanceStatus: input.instanceStatus ?? null,\n    waits,\n    attention: readAttention(input.attention),\n  }\n}\n\nfunction readAttention(value: unknown): RunAttention | null {\n  if (!value || typeof value !== 'object') return null\n  const reason = (value as Record<string, unknown>).reason\n  return { reason: typeof reason === 'string' && reason.length > 0 ? reason : null }\n}\n\nexport type GraphNodeDescriptor = {\n  id: string\n  type?: string\n}\n\n/**\n * Resolve the status the canvas paints for one node, including the START/END\n * conventions a step-less node has no execution record for.\n */\nexport function resolveNodeRunStatus(\n  execution: RunExecution,\n  node: GraphNodeDescriptor,\n  options: { currentStepId?: string | null; instanceStatus?: string | null } = {}\n): StepRunStatus {\n  const recorded = execution.stepStates.get(node.id)\n  if (recorded) return recorded.status\n\n  const currentStepId = options.currentStepId ?? execution.currentStepId\n  const instanceStatus = options.instanceStatus ?? execution.instanceStatus\n  const isCurrentStep = currentStepId === node.id\n  if (node.type === 'start') {\n    return isCurrentStep ? 'active' : 'completed'\n  }\n  if (node.type === 'end') {\n    return isCurrentStep || instanceStatus === 'COMPLETED' ? 'completed' : 'pending'\n  }\n  return 'pending'\n}\n\n/** Did this route carry the run? Matched by transition id first, endpoints second. */\nexport function isRouteTaken(\n  execution: RunExecution,\n  route: { transitionId?: string | null; fromStepId?: string | null; toStepId?: string | null }\n): boolean {\n  if (route.transitionId && execution.takenTransitionIds.has(route.transitionId)) return true\n  if (!route.fromStepId || !route.toStepId) return false\n  return execution.takenStepPairs.has(stepPairKey(route.fromStepId, route.toStepId))\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/workflows/lib/run-gantt.js

@@ -0,0 +1,180 @@
+import { stepInstanceStatusToRunStatus } from "./run-execution.js";
+import { toMillis } from "./run-duration.js";
+const MIN_COLLAPSIBLE_MS = 1e3;
+const COLLAPSE_FACTOR = 4;
+function median(values) {
+  if (values.length === 0) return 0;
+  const ordered = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(ordered.length / 2);
+  return ordered.length % 2 === 0 ? (ordered[middle - 1] + ordered[middle]) / 2 : ordered[middle];
+}
+function resolveCollapseThreshold(sliceDurations) {
+  const positive = sliceDurations.filter((duration) => duration > 0);
+  if (positive.length === 0) return Number.POSITIVE_INFINITY;
+  return Math.max(MIN_COLLAPSIBLE_MS, median(positive) * COLLAPSE_FACTOR);
+}
+function buildSlices(boundaries) {
+  const rawDurations = [];
+  for (let index = 1; index < boundaries.length; index += 1) {
+    rawDurations.push(boundaries[index] - boundaries[index - 1]);
+  }
+  const threshold = resolveCollapseThreshold(rawDurations);
+  const slices = [];
+  let renderedStart = 0;
+  for (let index = 1; index < boundaries.length; index += 1) {
+    const startMs = boundaries[index - 1];
+    const endMs = boundaries[index];
+    const durationMs = endMs - startMs;
+    const collapsed = durationMs > threshold;
+    const weight = collapsed ? threshold : durationMs;
+    slices.push({ startMs, endMs, durationMs, weight, collapsed, renderedStart });
+    renderedStart += weight;
+  }
+  return slices;
+}
+function renderedTotal(slices) {
+  return slices.reduce((total, slice) => total + slice.weight, 0);
+}
+function projectToRendered(slices, atMs) {
+  if (slices.length === 0) return 0;
+  if (atMs <= slices[0].startMs) return 0;
+  const last = slices[slices.length - 1];
+  if (atMs >= last.endMs) return last.renderedStart + last.weight;
+  for (const slice of slices) {
+    if (atMs >= slice.startMs && atMs <= slice.endMs) {
+      if (slice.durationMs === 0) return slice.renderedStart;
+      const progress = (atMs - slice.startMs) / slice.durationMs;
+      return slice.renderedStart + progress * slice.weight;
+    }
+  }
+  return last.renderedStart + last.weight;
+}
+function assignLanes(seeds) {
+  const laneByKey = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  const groupOrder = [];
+  for (const seed of seeds) {
+    const groupKey = seed.branchInstanceId ?? "__main__";
+    const existing = groups.get(groupKey);
+    if (existing) {
+      existing.push(seed);
+    } else {
+      groups.set(groupKey, [seed]);
+      groupOrder.push(groupKey);
+    }
+  }
+  let nextLaneBase = 0;
+  for (const groupKey of groupOrder) {
+    const groupSeeds = groups.get(groupKey) ?? [];
+    const laneEnds = [];
+    for (const seed of groupSeeds) {
+      let lane = laneEnds.findIndex((endMs) => endMs <= seed.startMs);
+      if (lane === -1) {
+        lane = laneEnds.length;
+        laneEnds.push(seed.endMs);
+      } else {
+        laneEnds[lane] = seed.endMs;
+      }
+      laneByKey.set(seed.key, nextLaneBase + lane);
+    }
+    nextLaneBase += Math.max(laneEnds.length, 1);
+  }
+  return laneByKey;
+}
+function buildRunGantt(input) {
+  const now = input.now ?? Date.now();
+  const seeds = [];
+  for (const [index, stepInstance] of input.stepInstances.entries()) {
+    const startMs2 = toMillis(stepInstance.enteredAt);
+    if (startMs2 === null) continue;
+    const recordedEnd = toMillis(stepInstance.exitedAt);
+    const running = recordedEnd === null;
+    const endMs2 = Math.max(recordedEnd ?? now, startMs2);
+    seeds.push({
+      key: stepInstance.id ?? `${stepInstance.stepId}-${index}`,
+      stepId: stepInstance.stepId,
+      stepName: stepInstance.stepName || stepInstance.stepId,
+      stepType: stepInstance.stepType || "",
+      status: stepInstanceStatusToRunStatus(stepInstance.status),
+      branchInstanceId: stepInstance.branchInstanceId ?? null,
+      startMs: startMs2,
+      endMs: endMs2,
+      running
+    });
+  }
+  seeds.sort((left, right) => left.startMs - right.startMs || left.endMs - right.endMs);
+  const instanceStart = toMillis(input.instanceStartedAt);
+  const instanceEnd = toMillis(input.instanceCompletedAt);
+  const candidateStarts = seeds.map((seed) => seed.startMs);
+  const candidateEnds = seeds.map((seed) => seed.endMs);
+  if (instanceStart !== null) candidateStarts.push(instanceStart);
+  if (instanceEnd !== null) candidateEnds.push(instanceEnd);
+  if (candidateStarts.length === 0) {
+    return {
+      bars: [],
+      laneCount: 0,
+      startMs: 0,
+      endMs: 0,
+      totalDurationMs: 0,
+      collapsedSegments: [],
+      collapsedDurationMs: 0
+    };
+  }
+  const startMs = Math.min(...candidateStarts);
+  const endMs = Math.max(...candidateEnds, startMs);
+  const boundarySet = /* @__PURE__ */ new Set([startMs, endMs]);
+  for (const seed of seeds) {
+    boundarySet.add(seed.startMs);
+    boundarySet.add(seed.endMs);
+  }
+  const boundaries = [...boundarySet].sort((left, right) => left - right);
+  const slices = buildSlices(boundaries);
+  const total = renderedTotal(slices);
+  const toRatio = (atMs) => total > 0 ? projectToRendered(slices, atMs) / total : 0;
+  const laneByKey = assignLanes(seeds);
+  const bars = seeds.map((seed) => {
+    const offsetRatio = toRatio(seed.startMs);
+    const endRatio = toRatio(seed.endMs);
+    const spansCollapsedWait = slices.some(
+      (slice) => slice.collapsed && slice.startMs >= seed.startMs && slice.endMs <= seed.endMs
+    );
+    return {
+      key: seed.key,
+      stepId: seed.stepId,
+      stepName: seed.stepName,
+      stepType: seed.stepType,
+      status: seed.status,
+      branchInstanceId: seed.branchInstanceId,
+      lane: laneByKey.get(seed.key) ?? 0,
+      startMs: seed.startMs,
+      endMs: seed.endMs,
+      durationMs: seed.endMs - seed.startMs,
+      offsetRatio,
+      widthRatio: Math.max(endRatio - offsetRatio, 0),
+      spansCollapsedWait,
+      running: seed.running
+    };
+  });
+  const collapsedSegments = slices.filter((slice) => slice.collapsed).map((slice) => ({
+    startMs: slice.startMs,
+    endMs: slice.endMs,
+    skippedMs: slice.durationMs - slice.weight,
+    offsetRatio: total > 0 ? slice.renderedStart / total : 0,
+    widthRatio: total > 0 ? slice.weight / total : 0
+  }));
+  return {
+    bars,
+    laneCount: bars.reduce((highest, bar) => Math.max(highest, bar.lane + 1), 0),
+    startMs,
+    endMs,
+    totalDurationMs: endMs - startMs,
+    collapsedSegments,
+    collapsedDurationMs: collapsedSegments.reduce((total_, segment) => total_ + segment.skippedMs, 0)
+  };
+}
+export {
+  COLLAPSE_FACTOR,
+  MIN_COLLAPSIBLE_MS,
+  buildRunGantt
+};
+//# sourceMappingURL=run-gantt.js.map

package/dist/modules/workflows/lib/run-gantt.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/run-gantt.ts"],
+  "sourcesContent": ["/**\n * Run Gantt model (spec \u00A78.3) \u2014 PURE.\n *\n * > \"**Timeline** \u2014 a true clock-time **Gantt** (bars per step/activity/task/\n * > signal, parallel branches as overlapping lanes, with collapsed-wait\n * > rendering so a 3-day task deadline doesn't flatten the rest; this is what\n * > makes latency and human-wait visible)\"\n *\n * Two problems the naive version does not solve.\n *\n * **Collapsed waits.** A run that spends 1s executing and three days waiting\n * for an approval is 99.999% wait on a linear axis: every automated step\n * collapses to a sub-pixel sliver and the chart shows nothing. So the axis is\n * PIECEWISE-LINEAR. The run is cut at every start and end into slices; a slice\n * longer than the collapse threshold is rendered at the threshold's width and\n * flagged, so the wait is visible AS a wait without eating the chart. Time is\n * still monotonic and every bar keeps its true duration in `durationMs` \u2014 the\n * compression is a rendering decision, never a reported number.\n *\n * **Lanes.** Parallel branches genuinely overlap in clock time, so they cannot\n * share a row. Bars are grouped by `branchInstanceId` (the engine's own branch\n * token) and packed greedily inside each group, which keeps one branch reading\n * top-to-bottom instead of scattering it across the chart.\n */\n\nimport type { StepRunStatus } from './status-colors'\nimport { stepInstanceStatusToRunStatus, type RunStepInstanceInput } from './run-execution'\nimport { toMillis } from './run-duration'\n\n/** A slice shorter than this is never compressed \u2014 sub-second runs stay linear. */\nexport const MIN_COLLAPSIBLE_MS = 1000\n\n/**\n * How many times the typical slice a slice must exceed before it is treated as\n * a wait rather than work. Four is deliberately conservative: it collapses the\n * three-day approval and leaves an ordinary slow HTTP call alone.\n */\nexport const COLLAPSE_FACTOR = 4\n\nexport type GanttBar = {\n  key: string\n  stepId: string\n  stepName: string\n  stepType: string\n  status: StepRunStatus\n  branchInstanceId: string | null\n  lane: number\n  startMs: number\n  endMs: number\n  /** TRUE elapsed time. Never the compressed one. */\n  durationMs: number\n  /** Position across the rendered (compressed) axis, 0..1. */\n  offsetRatio: number\n  widthRatio: number\n  /** The bar spans at least one collapsed slice, i.e. most of it is waiting. */\n  spansCollapsedWait: boolean\n  /** The step had not finished when the model was built. */\n  running: boolean\n}\n\nexport type GanttCollapsedSegment = {\n  startMs: number\n  endMs: number\n  skippedMs: number\n  offsetRatio: number\n  widthRatio: number\n}\n\nexport type GanttModel = {\n  bars: GanttBar[]\n  laneCount: number\n  startMs: number\n  endMs: number\n  /** True wall-clock span of the run. */\n  totalDurationMs: number\n  collapsedSegments: GanttCollapsedSegment[]\n  /** Sum of everything the collapsed segments hide, for the \"N hidden\" caption. */\n  collapsedDurationMs: number\n}\n\ntype Slice = {\n  startMs: number\n  endMs: number\n  durationMs: number\n  weight: number\n  collapsed: boolean\n  renderedStart: number\n}\n\nfunction median(values: readonly number[]): number {\n  if (values.length === 0) return 0\n  const ordered = [...values].sort((left, right) => left - right)\n  const middle = Math.floor(ordered.length / 2)\n  return ordered.length % 2 === 0 ? (ordered[middle - 1] + ordered[middle]) / 2 : ordered[middle]\n}\n\nfunction resolveCollapseThreshold(sliceDurations: readonly number[]): number {\n  const positive = sliceDurations.filter((duration) => duration > 0)\n  if (positive.length === 0) return Number.POSITIVE_INFINITY\n  return Math.max(MIN_COLLAPSIBLE_MS, median(positive) * COLLAPSE_FACTOR)\n}\n\nfunction buildSlices(boundaries: readonly number[]): Slice[] {\n  const rawDurations: number[] = []\n  for (let index = 1; index < boundaries.length; index += 1) {\n    rawDurations.push(boundaries[index] - boundaries[index - 1])\n  }\n  const threshold = resolveCollapseThreshold(rawDurations)\n\n  const slices: Slice[] = []\n  let renderedStart = 0\n  for (let index = 1; index < boundaries.length; index += 1) {\n    const startMs = boundaries[index - 1]\n    const endMs = boundaries[index]\n    const durationMs = endMs - startMs\n    const collapsed = durationMs > threshold\n    const weight = collapsed ? threshold : durationMs\n    slices.push({ startMs, endMs, durationMs, weight, collapsed, renderedStart })\n    renderedStart += weight\n  }\n  return slices\n}\n\nfunction renderedTotal(slices: readonly Slice[]): number {\n  return slices.reduce((total, slice) => total + slice.weight, 0)\n}\n\n/** Map a wall-clock instant onto the compressed axis, in rendered units. */\nfunction projectToRendered(slices: readonly Slice[], atMs: number): number {\n  if (slices.length === 0) return 0\n  if (atMs <= slices[0].startMs) return 0\n  const last = slices[slices.length - 1]\n  if (atMs >= last.endMs) return last.renderedStart + last.weight\n\n  for (const slice of slices) {\n    if (atMs >= slice.startMs && atMs <= slice.endMs) {\n      if (slice.durationMs === 0) return slice.renderedStart\n      const progress = (atMs - slice.startMs) / slice.durationMs\n      return slice.renderedStart + progress * slice.weight\n    }\n  }\n  return last.renderedStart + last.weight\n}\n\ntype BarSeed = {\n  key: string\n  stepId: string\n  stepName: string\n  stepType: string\n  status: StepRunStatus\n  branchInstanceId: string | null\n  startMs: number\n  endMs: number\n  running: boolean\n}\n\n/**\n * Lanes per branch: every bar carrying the same `branchInstanceId` is packed\n * into that branch's own block of lanes, so a parallel branch reads as one\n * band rather than being scattered across the chart by a global packer.\n */\nfunction assignLanes(seeds: readonly BarSeed[]): Map<string, number> {\n  const laneByKey = new Map<string, number>()\n  const groups = new Map<string, BarSeed[]>()\n  const groupOrder: string[] = []\n\n  for (const seed of seeds) {\n    const groupKey = seed.branchInstanceId ?? '__main__'\n    const existing = groups.get(groupKey)\n    if (existing) {\n      existing.push(seed)\n    } else {\n      groups.set(groupKey, [seed])\n      groupOrder.push(groupKey)\n    }\n  }\n\n  let nextLaneBase = 0\n  for (const groupKey of groupOrder) {\n    const groupSeeds = groups.get(groupKey) ?? []\n    const laneEnds: number[] = []\n    for (const seed of groupSeeds) {\n      let lane = laneEnds.findIndex((endMs) => endMs <= seed.startMs)\n      if (lane === -1) {\n        lane = laneEnds.length\n        laneEnds.push(seed.endMs)\n      } else {\n        laneEnds[lane] = seed.endMs\n      }\n      laneByKey.set(seed.key, nextLaneBase + lane)\n    }\n    nextLaneBase += Math.max(laneEnds.length, 1)\n  }\n\n  return laneByKey\n}\n\nexport type BuildGanttInput = {\n  stepInstances: readonly RunStepInstanceInput[]\n  /** Instance start, so the axis begins where the run began even if step 1 is late. */\n  instanceStartedAt?: string | Date | null\n  instanceCompletedAt?: string | Date | null\n  /** Injected for determinism \u2014 an unfinished step is measured against this. */\n  now?: number\n}\n\nexport function buildRunGantt(input: BuildGanttInput): GanttModel {\n  const now = input.now ?? Date.now()\n\n  const seeds: BarSeed[] = []\n  for (const [index, stepInstance] of input.stepInstances.entries()) {\n    const startMs = toMillis(stepInstance.enteredAt)\n    if (startMs === null) continue\n    const recordedEnd = toMillis(stepInstance.exitedAt)\n    const running = recordedEnd === null\n    const endMs = Math.max(recordedEnd ?? now, startMs)\n    seeds.push({\n      key: stepInstance.id ?? `${stepInstance.stepId}-${index}`,\n      stepId: stepInstance.stepId,\n      stepName: stepInstance.stepName || stepInstance.stepId,\n      stepType: stepInstance.stepType || '',\n      status: stepInstanceStatusToRunStatus(stepInstance.status),\n      branchInstanceId: stepInstance.branchInstanceId ?? null,\n      startMs,\n      endMs,\n      running,\n    })\n  }\n\n  seeds.sort((left, right) => left.startMs - right.startMs || left.endMs - right.endMs)\n\n  const instanceStart = toMillis(input.instanceStartedAt)\n  const instanceEnd = toMillis(input.instanceCompletedAt)\n\n  const candidateStarts = seeds.map((seed) => seed.startMs)\n  const candidateEnds = seeds.map((seed) => seed.endMs)\n  if (instanceStart !== null) candidateStarts.push(instanceStart)\n  if (instanceEnd !== null) candidateEnds.push(instanceEnd)\n\n  if (candidateStarts.length === 0) {\n    return {\n      bars: [],\n      laneCount: 0,\n      startMs: 0,\n      endMs: 0,\n      totalDurationMs: 0,\n      collapsedSegments: [],\n      collapsedDurationMs: 0,\n    }\n  }\n\n  const startMs = Math.min(...candidateStarts)\n  const endMs = Math.max(...candidateEnds, startMs)\n\n  const boundarySet = new Set<number>([startMs, endMs])\n  for (const seed of seeds) {\n    boundarySet.add(seed.startMs)\n    boundarySet.add(seed.endMs)\n  }\n  const boundaries = [...boundarySet].sort((left, right) => left - right)\n\n  const slices = buildSlices(boundaries)\n  const total = renderedTotal(slices)\n  const toRatio = (atMs: number) => (total > 0 ? projectToRendered(slices, atMs) / total : 0)\n\n  const laneByKey = assignLanes(seeds)\n\n  const bars: GanttBar[] = seeds.map((seed) => {\n    const offsetRatio = toRatio(seed.startMs)\n    const endRatio = toRatio(seed.endMs)\n    const spansCollapsedWait = slices.some(\n      (slice) => slice.collapsed && slice.startMs >= seed.startMs && slice.endMs <= seed.endMs\n    )\n    return {\n      key: seed.key,\n      stepId: seed.stepId,\n      stepName: seed.stepName,\n      stepType: seed.stepType,\n      status: seed.status,\n      branchInstanceId: seed.branchInstanceId,\n      lane: laneByKey.get(seed.key) ?? 0,\n      startMs: seed.startMs,\n      endMs: seed.endMs,\n      durationMs: seed.endMs - seed.startMs,\n      offsetRatio,\n      widthRatio: Math.max(endRatio - offsetRatio, 0),\n      spansCollapsedWait,\n      running: seed.running,\n    }\n  })\n\n  const collapsedSegments: GanttCollapsedSegment[] = slices\n    .filter((slice) => slice.collapsed)\n    .map((slice) => ({\n      startMs: slice.startMs,\n      endMs: slice.endMs,\n      skippedMs: slice.durationMs - slice.weight,\n      offsetRatio: total > 0 ? slice.renderedStart / total : 0,\n      widthRatio: total > 0 ? slice.weight / total : 0,\n    }))\n\n  return {\n    bars,\n    laneCount: bars.reduce((highest, bar) => Math.max(highest, bar.lane + 1), 0),\n    startMs,\n    endMs,\n    totalDurationMs: endMs - startMs,\n    collapsedSegments,\n    collapsedDurationMs: collapsedSegments.reduce((total_, segment) => total_ + segment.skippedMs, 0),\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["startMs", "endMs"]
+}

package/dist/modules/workflows/lib/run-outcome-evidence.js

@@ -0,0 +1,33 @@
+import { StepInstance, WorkflowEvent } from "../data/entities.js";
+import {
+  EMPTY_RUN_OUTCOME_EVIDENCE,
+  RUN_OUTCOME_FAILED_STEP_STATUS,
+  RUN_OUTCOME_FAILURE_EVENT_TYPES,
+  RUN_OUTCOME_SKIPPED_STEP_STATUS,
+  RUN_OUTCOME_WARNING_EVENT_TYPES
+} from "./run-outcome.js";
+async function collectRunOutcomeEvidence(em, instance, terminalStatus) {
+  if (terminalStatus !== "COMPLETED") {
+    return { terminalStatus, ...EMPTY_RUN_OUTCOME_EVIDENCE };
+  }
+  const scope = {
+    workflowInstanceId: instance.id,
+    tenantId: instance.tenantId,
+    organizationId: instance.organizationId
+  };
+  const [failedSteps, failureEvents, skippedSteps, warningEvents] = await Promise.all([
+    em.count(StepInstance, { ...scope, status: RUN_OUTCOME_FAILED_STEP_STATUS }),
+    em.count(WorkflowEvent, { ...scope, eventType: { $in: [...RUN_OUTCOME_FAILURE_EVENT_TYPES] } }),
+    em.count(StepInstance, { ...scope, status: RUN_OUTCOME_SKIPPED_STEP_STATUS }),
+    em.count(WorkflowEvent, { ...scope, eventType: { $in: [...RUN_OUTCOME_WARNING_EVENT_TYPES] } })
+  ]);
+  return {
+    terminalStatus,
+    failureEvidenceCount: failedSteps + failureEvents,
+    warningEvidenceCount: skippedSteps + warningEvents
+  };
+}
+export {
+  collectRunOutcomeEvidence
+};
+//# sourceMappingURL=run-outcome-evidence.js.map

package/dist/modules/workflows/lib/run-outcome-evidence.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/run-outcome-evidence.ts"],
+  "sourcesContent": ["/**\n * Workflows Module \u2014 Run Outcome Evidence (the data-access half).\n *\n * Counts what the run RECORDED about itself so `resolveRunOutcome`\n * (`lib/run-outcome.ts`, pure) can reach a verdict. Nothing here decides\n * anything: the vocabulary and the precedence both live in the pure module, and\n * this file only turns rows into the counts that module asks for.\n *\n * Every query carries `tenantId` AND `organizationId` on top of the instance id.\n * The instance id alone would already be unique, but a scoped query cannot be\n * turned into a cross-tenant read by a later refactor that widens it.\n */\n\nimport type { EntityManager } from '@mikro-orm/core'\nimport { StepInstance, WorkflowEvent, type WorkflowInstance } from '../data/entities'\nimport {\n  EMPTY_RUN_OUTCOME_EVIDENCE,\n  RUN_OUTCOME_FAILED_STEP_STATUS,\n  RUN_OUTCOME_FAILURE_EVENT_TYPES,\n  RUN_OUTCOME_SKIPPED_STEP_STATUS,\n  RUN_OUTCOME_WARNING_EVENT_TYPES,\n  type RunOutcomeEvidence,\n} from './run-outcome'\n\n/**\n * Count the run's recorded failure and warning evidence.\n *\n * Short-circuits for every terminal status except `COMPLETED`: `cancelled`,\n * `compensated` and `failure` are decided by the lifecycle alone, so querying\n * for evidence that cannot change the verdict would add four round trips to\n * every failing run's termination path.\n */\nexport async function collectRunOutcomeEvidence(\n  em: EntityManager,\n  instance: Pick<WorkflowInstance, 'id' | 'tenantId' | 'organizationId'>,\n  terminalStatus: string,\n): Promise<RunOutcomeEvidence> {\n  if (terminalStatus !== 'COMPLETED') {\n    return { terminalStatus, ...EMPTY_RUN_OUTCOME_EVIDENCE }\n  }\n\n  const scope = {\n    workflowInstanceId: instance.id,\n    tenantId: instance.tenantId,\n    organizationId: instance.organizationId,\n  }\n\n  const [failedSteps, failureEvents, skippedSteps, warningEvents] = await Promise.all([\n    em.count(StepInstance, { ...scope, status: RUN_OUTCOME_FAILED_STEP_STATUS }),\n    em.count(WorkflowEvent, { ...scope, eventType: { $in: [...RUN_OUTCOME_FAILURE_EVENT_TYPES] } }),\n    em.count(StepInstance, { ...scope, status: RUN_OUTCOME_SKIPPED_STEP_STATUS }),\n    em.count(WorkflowEvent, { ...scope, eventType: { $in: [...RUN_OUTCOME_WARNING_EVENT_TYPES] } }),\n  ])\n\n  return {\n    terminalStatus,\n    failureEvidenceCount: failedSteps + failureEvents,\n    warningEvidenceCount: skippedSteps + warningEvents,\n  }\n}\n"],
+  "mappings": "AAcA,SAAS,cAAc,qBAA4C;AACnE;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAUP,eAAsB,0BACpB,IACA,UACA,gBAC6B;AAC7B,MAAI,mBAAmB,aAAa;AAClC,WAAO,EAAE,gBAAgB,GAAG,2BAA2B;AAAA,EACzD;AAEA,QAAM,QAAQ;AAAA,IACZ,oBAAoB,SAAS;AAAA,IAC7B,UAAU,SAAS;AAAA,IACnB,gBAAgB,SAAS;AAAA,EAC3B;AAEA,QAAM,CAAC,aAAa,eAAe,cAAc,aAAa,IAAI,MAAM,QAAQ,IAAI;AAAA,IAClF,GAAG,MAAM,cAAc,EAAE,GAAG,OAAO,QAAQ,+BAA+B,CAAC;AAAA,IAC3E,GAAG,MAAM,eAAe,EAAE,GAAG,OAAO,WAAW,EAAE,KAAK,CAAC,GAAG,+BAA+B,EAAE,EAAE,CAAC;AAAA,IAC9F,GAAG,MAAM,cAAc,EAAE,GAAG,OAAO,QAAQ,gCAAgC,CAAC;AAAA,IAC5E,GAAG,MAAM,eAAe,EAAE,GAAG,OAAO,WAAW,EAAE,KAAK,CAAC,GAAG,+BAA+B,EAAE,EAAE,CAAC;AAAA,EAChG,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA,sBAAsB,cAAc;AAAA,IACpC,sBAAsB,eAAe;AAAA,EACvC;AACF;",
+  "names": []
+}

package/dist/modules/workflows/lib/run-outcome.js

@@ -0,0 +1,48 @@
+const WORKFLOW_RUN_OUTCOMES = [
+  "success",
+  "success_with_warnings",
+  "partial_failure",
+  "failure",
+  "cancelled",
+  "compensated"
+];
+const RUN_OUTCOME_FAILED_STEP_STATUS = "FAILED";
+const RUN_OUTCOME_SKIPPED_STEP_STATUS = "SKIPPED";
+const RUN_OUTCOME_FAILURE_EVENT_TYPES = ["ACTIVITY_FAILED"];
+const RUN_OUTCOME_WARNING_EVENT_TYPES = ["STEP_SKIPPED"];
+const EMPTY_RUN_OUTCOME_EVIDENCE = {
+  failureEvidenceCount: 0,
+  warningEvidenceCount: 0
+};
+function resolveRunOutcome(evidence) {
+  if (evidence.terminalStatus === "CANCELLED") return "cancelled";
+  if (evidence.terminalStatus === "COMPENSATED") return "compensated";
+  if (evidence.terminalStatus !== "COMPLETED") return "failure";
+  if (evidence.failureEvidenceCount > 0) return "partial_failure";
+  if (evidence.warningEvidenceCount > 0) return "success_with_warnings";
+  return "success";
+}
+function isDegradedRunOutcome(outcome) {
+  return outcome === "partial_failure";
+}
+const WORKFLOW_ATTENTION_OUTCOMES = ["partial_failure"];
+function isRetryableRunOutcome(outcome) {
+  return outcome === "failure";
+}
+function isWorkflowRunOutcome(value) {
+  return typeof value === "string" && WORKFLOW_RUN_OUTCOMES.includes(value);
+}
+export {
+  EMPTY_RUN_OUTCOME_EVIDENCE,
+  RUN_OUTCOME_FAILED_STEP_STATUS,
+  RUN_OUTCOME_FAILURE_EVENT_TYPES,
+  RUN_OUTCOME_SKIPPED_STEP_STATUS,
+  RUN_OUTCOME_WARNING_EVENT_TYPES,
+  WORKFLOW_ATTENTION_OUTCOMES,
+  WORKFLOW_RUN_OUTCOMES,
+  isDegradedRunOutcome,
+  isRetryableRunOutcome,
+  isWorkflowRunOutcome,
+  resolveRunOutcome
+};
+//# sourceMappingURL=run-outcome.js.map

package/dist/modules/workflows/lib/run-outcome.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/run-outcome.ts"],
+  "sourcesContent": ["/**\n * Workflows Module \u2014 Run Outcome (pure)\n *\n * The run's **verdict**, alongside \u2014 never instead of \u2014 its lifecycle `status`.\n *\n * `status` answers *did it reach the end?* and drives control flow (is this run\n * active? may the executor advance it? can it be retried?). It is untouched by\n * this module. `outcome` answers the other question the same enum used to be\n * asked to answer on its own: *did everything it attempted actually happen?*\n * Conflating the two is why a run that swallowed three failed writes reported\n * the same `COMPLETED` as a clean one.\n *\n * | outcome                 | meaning                                                       |\n * |-------------------------|---------------------------------------------------------------|\n * | `success`               | Reached END. Nothing failed, nothing was suppressed.           |\n * | `success_with_warnings` | Reached END and did everything asked, but something is worth reading. |\n * | `partial_failure`       | Reached END, but at least one activity or step failed and was tolerated. |\n * | `failure`               | Did not reach END.                                             |\n * | `cancelled`             | A human stopped it.                                            |\n * | `compensated`           | Rolled back.                                                   |\n *\n * **The invariant this module exists for:**\n *\n * > A run that suppressed at least one failure MUST NOT be `success`.\n *\n * It holds by construction \u2014 `resolveRunOutcome` consults\n * `failureEvidenceCount` before it can ever return `success`, and it is the ONE\n * decision point, so no exit point can assemble a friendlier verdict of its own.\n *\n * PURE: no ORM, DI, React or registry imports, exactly like `lib/error-routing.ts`,\n * `lib/breach-routing.ts` and `lib/outcome-routing.ts`. The impure half \u2014\n * counting the recorded evidence \u2014 lives in `lib/run-outcome-evidence.ts`.\n */\n\nexport const WORKFLOW_RUN_OUTCOMES = [\n  'success',\n  'success_with_warnings',\n  'partial_failure',\n  'failure',\n  'cancelled',\n  'compensated',\n] as const\n\nexport type WorkflowRunOutcome = (typeof WORKFLOW_RUN_OUTCOMES)[number]\n\n/**\n * `StepInstance.status` values that ARE recorded failure evidence.\n *\n * A step row only becomes FAILED through `markStepInstanceFailed`, which the\n * enabling fix made unconditional \u2014 a tolerated failure is recorded exactly like\n * a fatal one, because tolerating a failure is a routing decision, not a reason\n * to forget it happened.\n */\nexport const RUN_OUTCOME_FAILED_STEP_STATUS = 'FAILED'\n\n/** `StepInstance.status` value that is a warning rather than a failure. */\nexport const RUN_OUTCOME_SKIPPED_STEP_STATUS = 'SKIPPED'\n\n/**\n * Event types that are failure evidence a step row does NOT already carry.\n *\n * `ACTIVITY_FAILED` is the one that matters: a transition's activities run\n * LEAVING their source step, whose row has already exited COMPLETED, so a\n * transition-level `continueOnActivityFailure` (the shipped `order-approval`\n * shape) leaves no failed step row anywhere \u2014 only this event. `STEP_FAILED` is\n * deliberately absent: it is one-to-one with a FAILED row and counting both\n * would double-count the same failure.\n */\nexport const RUN_OUTCOME_FAILURE_EVENT_TYPES = ['ACTIVITY_FAILED'] as const\n\n/** Event types that are warning evidence a step row does not already carry. */\nexport const RUN_OUTCOME_WARNING_EVENT_TYPES = ['STEP_SKIPPED'] as const\n\n/**\n * What the run recorded about itself, already counted.\n *\n * Counts rather than rows because the decision is a `> 0` test and the collector\n * answers it with `COUNT(*)`; the numbers are evidence for the verdict, not a\n * reported metric.\n *\n * **Known imprecision, deliberately not papered over:** a run that failed, was\n * retried and then completed still carries its pre-retry `ACTIVITY_FAILED`\n * rows, so it reports `partial_failure`. The engine records no attempt boundary\n * to subtract them by, and over-reporting a degraded run is the safe direction\n * for a change whose whole purpose is to stop under-reporting one.\n */\nexport type RunOutcomeEvidence = {\n  /** The status the run is terminating with. */\n  terminalStatus: string\n  /** FAILED step rows plus `ACTIVITY_FAILED` events. */\n  failureEvidenceCount: number\n  /** SKIPPED step rows plus `STEP_SKIPPED` events. */\n  warningEvidenceCount: number\n}\n\nexport const EMPTY_RUN_OUTCOME_EVIDENCE: Omit<RunOutcomeEvidence, 'terminalStatus'> = {\n  failureEvidenceCount: 0,\n  warningEvidenceCount: 0,\n}\n\n/**\n * The single decision point. Terminal status first, because `cancelled`,\n * `compensated` and `failure` are facts about the lifecycle that no amount of\n * evidence can argue with; only a run that actually reached END is judged on\n * what it recorded.\n */\nexport function resolveRunOutcome(evidence: RunOutcomeEvidence): WorkflowRunOutcome {\n  if (evidence.terminalStatus === 'CANCELLED') return 'cancelled'\n  if (evidence.terminalStatus === 'COMPENSATED') return 'compensated'\n  if (evidence.terminalStatus !== 'COMPLETED') return 'failure'\n  if (evidence.failureEvidenceCount > 0) return 'partial_failure'\n  if (evidence.warningEvidenceCount > 0) return 'success_with_warnings'\n  return 'success'\n}\n\n/** True for a verdict an operator must look at even though the run reached END. */\nexport function isDegradedRunOutcome(outcome: WorkflowRunOutcome | null | undefined): boolean {\n  return outcome === 'partial_failure'\n}\n\n/**\n * Outcomes the needs-attention / failure queue must include.\n *\n * A `partial_failure` is precisely the run nobody looks at because it said\n * COMPLETED \u2014 which is the failure this whole change exists to remove.\n */\nexport const WORKFLOW_ATTENTION_OUTCOMES = ['partial_failure'] as const\n\n/**\n * `partial_failure` is NOT retryable as a whole run (maintainer decision,\n * 2026-07-30). It reached END, so replaying the graph would re-run every part\n * that already succeeded \u2014 duplicating their effects to re-attempt the parts\n * that did not. Recovery is rerun-from-step on the specific failed step, which\n * is what that feature is for and what the enabling fix unblocked.\n */\nexport function isRetryableRunOutcome(outcome: WorkflowRunOutcome | null | undefined): boolean {\n  return outcome === 'failure'\n}\n\nexport function isWorkflowRunOutcome(value: unknown): value is WorkflowRunOutcome {\n  return typeof value === 'string' && (WORKFLOW_RUN_OUTCOMES as readonly string[]).includes(value)\n}\n"],
+  "mappings": "AAkCO,MAAM,wBAAwB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAYO,MAAM,iCAAiC;AAGvC,MAAM,kCAAkC;AAYxC,MAAM,kCAAkC,CAAC,iBAAiB;AAG1D,MAAM,kCAAkC,CAAC,cAAc;AAwBvD,MAAM,6BAAyE;AAAA,EACpF,sBAAsB;AAAA,EACtB,sBAAsB;AACxB;AAQO,SAAS,kBAAkB,UAAkD;AAClF,MAAI,SAAS,mBAAmB,YAAa,QAAO;AACpD,MAAI,SAAS,mBAAmB,cAAe,QAAO;AACtD,MAAI,SAAS,mBAAmB,YAAa,QAAO;AACpD,MAAI,SAAS,uBAAuB,EAAG,QAAO;AAC9C,MAAI,SAAS,uBAAuB,EAAG,QAAO;AAC9C,SAAO;AACT;AAGO,SAAS,qBAAqB,SAAyD;AAC5F,SAAO,YAAY;AACrB;AAQO,MAAM,8BAA8B,CAAC,iBAAiB;AAStD,SAAS,sBAAsB,SAAyD;AAC7F,SAAO,YAAY;AACrB;AAEO,SAAS,qBAAqB,OAA6C;AAChF,SAAO,OAAO,UAAU,YAAa,sBAA4C,SAAS,KAAK;AACjG;",
+  "names": []
+}

package/dist/modules/workflows/lib/sample-resolver.js

@@ -0,0 +1,71 @@
+const PLACEHOLDER_DATE_SAMPLE = "2026-01-01T00:00:00.000Z";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function placeholderValueFor(entry) {
+  switch (entry.type) {
+    case "text":
+      return "text";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "date":
+      return PLACEHOLDER_DATE_SAMPLE;
+    case "select":
+      return entry.options && entry.options.length > 0 ? entry.options[0] : "option";
+    case "object":
+      return {};
+    default:
+      return null;
+  }
+}
+function assignAtPath(target, path, value) {
+  const segments = path.split(".").filter((segment) => segment.length > 0);
+  if (segments.length === 0) return;
+  let cursor = target;
+  for (const segment of segments.slice(0, -1)) {
+    const existing = cursor[segment];
+    if (isPlainObject(existing)) {
+      cursor = existing;
+    } else {
+      const created = {};
+      cursor[segment] = created;
+      cursor = created;
+    }
+  }
+  const leaf = segments[segments.length - 1];
+  const current = cursor[leaf];
+  if (isPlainObject(current) && isPlainObject(value)) return;
+  cursor[leaf] = value;
+}
+function buildPlaceholderFromLedger(entries) {
+  const placeholder = {};
+  for (const entry of entries) {
+    assignAtPath(placeholder, entry.path, placeholderValueFor(entry));
+  }
+  return placeholder;
+}
+function resolveStepSample({
+  stepId,
+  samples,
+  testOutputs,
+  ledgerEntries
+}) {
+  const pinned = samples ? samples[stepId] : void 0;
+  if (pinned !== void 0) {
+    return { data: pinned.data, source: "pin" };
+  }
+  if (testOutputs && Object.prototype.hasOwnProperty.call(testOutputs, stepId)) {
+    return { data: testOutputs[stepId], source: "test" };
+  }
+  if (ledgerEntries && ledgerEntries.length > 0) {
+    return { data: buildPlaceholderFromLedger(ledgerEntries), source: "placeholder" };
+  }
+  return null;
+}
+export {
+  buildPlaceholderFromLedger,
+  resolveStepSample
+};
+//# sourceMappingURL=sample-resolver.js.map

package/dist/modules/workflows/lib/sample-resolver.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/sample-resolver.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - per-step sample resolution (spec\n * 2026-07-26-workflows-ux-redesign.md section 3.6).\n *\n * Pure, dependency-free precedence chain for the context sample shown next to\n * a step in the editor and used to seed Test-step runs:\n *\n *   1. explicit pin \u2014 `metadata.editor.samples[stepId]` written by the user\n *   2. in-memory test output \u2014 the last Test-step result for the step\n *   3. ledger-derived placeholder \u2014 synthesized from the step's ledger\n *      entries so the preview always has an honest, typed shape\n *\n * Returns null when none of the three sources can produce anything. No React,\n * no ORM, no DI \u2014 loadable from the browser bundle and server routes alike.\n */\n\nexport type ResolvedSampleSource = 'pin' | 'test' | 'placeholder'\n\nexport interface ResolvedStepSample {\n  data: unknown\n  source: ResolvedSampleSource\n}\n\nexport interface PinnedSampleEnvelope {\n  pinnedAt: string\n  source: 'manual' | 'test'\n  data: unknown\n}\n\nexport interface SampleLedgerEntry {\n  path: string\n  type: string\n  options?: string[]\n}\n\nexport interface ResolveStepSampleInput {\n  stepId: string\n  samples?: Record<string, PinnedSampleEnvelope> | null\n  testOutputs?: Record<string, unknown> | null\n  ledgerEntries?: SampleLedgerEntry[] | null\n}\n\nconst PLACEHOLDER_DATE_SAMPLE = '2026-01-01T00:00:00.000Z'\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction placeholderValueFor(entry: SampleLedgerEntry): unknown {\n  switch (entry.type) {\n    case 'text':\n      return 'text'\n    case 'number':\n      return 0\n    case 'boolean':\n      return false\n    case 'date':\n      return PLACEHOLDER_DATE_SAMPLE\n    case 'select':\n      return entry.options && entry.options.length > 0 ? entry.options[0] : 'option'\n    case 'object':\n      return {}\n    default:\n      return null\n  }\n}\n\nfunction assignAtPath(target: Record<string, unknown>, path: string, value: unknown): void {\n  const segments = path.split('.').filter((segment) => segment.length > 0)\n  if (segments.length === 0) return\n  let cursor = target\n  for (const segment of segments.slice(0, -1)) {\n    const existing = cursor[segment]\n    if (isPlainObject(existing)) {\n      cursor = existing\n    } else {\n      const created: Record<string, unknown> = {}\n      cursor[segment] = created\n      cursor = created\n    }\n  }\n  const leaf = segments[segments.length - 1]\n  const current = cursor[leaf]\n  if (isPlainObject(current) && isPlainObject(value)) return\n  cursor[leaf] = value\n}\n\nexport function buildPlaceholderFromLedger(entries: SampleLedgerEntry[]): Record<string, unknown> {\n  const placeholder: Record<string, unknown> = {}\n  for (const entry of entries) {\n    assignAtPath(placeholder, entry.path, placeholderValueFor(entry))\n  }\n  return placeholder\n}\n\nexport function resolveStepSample({\n  stepId,\n  samples,\n  testOutputs,\n  ledgerEntries,\n}: ResolveStepSampleInput): ResolvedStepSample | null {\n  const pinned = samples ? samples[stepId] : undefined\n  if (pinned !== undefined) {\n    return { data: pinned.data, source: 'pin' }\n  }\n  if (testOutputs && Object.prototype.hasOwnProperty.call(testOutputs, stepId)) {\n    return { data: testOutputs[stepId], source: 'test' }\n  }\n  if (ledgerEntries && ledgerEntries.length > 0) {\n    return { data: buildPlaceholderFromLedger(ledgerEntries), source: 'placeholder' }\n  }\n  return null\n}\n"],
+  "mappings": "AA0CA,MAAM,0BAA0B;AAEhC,SAAS,cAAc,OAAkD;AACvE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAS,oBAAoB,OAAmC;AAC9D,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO,MAAM,WAAW,MAAM,QAAQ,SAAS,IAAI,MAAM,QAAQ,CAAC,IAAI;AAAA,IACxE,KAAK;AACH,aAAO,CAAC;AAAA,IACV;AACE,aAAO;AAAA,EACX;AACF;AAEA,SAAS,aAAa,QAAiC,MAAc,OAAsB;AACzF,QAAM,WAAW,KAAK,MAAM,GAAG,EAAE,OAAO,CAAC,YAAY,QAAQ,SAAS,CAAC;AACvE,MAAI,SAAS,WAAW,EAAG;AAC3B,MAAI,SAAS;AACb,aAAW,WAAW,SAAS,MAAM,GAAG,EAAE,GAAG;AAC3C,UAAM,WAAW,OAAO,OAAO;AAC/B,QAAI,cAAc,QAAQ,GAAG;AAC3B,eAAS;AAAA,IACX,OAAO;AACL,YAAM,UAAmC,CAAC;AAC1C,aAAO,OAAO,IAAI;AAClB,eAAS;AAAA,IACX;AAAA,EACF;AACA,QAAM,OAAO,SAAS,SAAS,SAAS,CAAC;AACzC,QAAM,UAAU,OAAO,IAAI;AAC3B,MAAI,cAAc,OAAO,KAAK,cAAc,KAAK,EAAG;AACpD,SAAO,IAAI,IAAI;AACjB;AAEO,SAAS,2BAA2B,SAAuD;AAChG,QAAM,cAAuC,CAAC;AAC9C,aAAW,SAAS,SAAS;AAC3B,iBAAa,aAAa,MAAM,MAAM,oBAAoB,KAAK,CAAC;AAAA,EAClE;AACA,SAAO;AACT;AAEO,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAsD;AACpD,QAAM,SAAS,UAAU,QAAQ,MAAM,IAAI;AAC3C,MAAI,WAAW,QAAW;AACxB,WAAO,EAAE,MAAM,OAAO,MAAM,QAAQ,MAAM;AAAA,EAC5C;AACA,MAAI,eAAe,OAAO,UAAU,eAAe,KAAK,aAAa,MAAM,GAAG;AAC5E,WAAO,EAAE,MAAM,YAAY,MAAM,GAAG,QAAQ,OAAO;AAAA,EACrD;AACA,MAAI,iBAAiB,cAAc,SAAS,GAAG;AAC7C,WAAO,EAAE,MAAM,2BAA2B,aAAa,GAAG,QAAQ,cAAc;AAAA,EAClF;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/modules/workflows/lib/seeds.js

@@ -32,7 +32,7 @@ async function seedWorkflowDefinition(em, scope, fileName) {
     workflowId,
     tenantId: scope.tenantId,
     organizationId: scope.organizationId
-  });
+  }, { orderBy: { version: "DESC" } });
   if (existing) {
     const seedStepCount = seed.definition.steps.length;
     const existingStepCount = existing.definition.steps.length;

package/dist/modules/workflows/lib/seeds.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/modules/workflows/lib/seeds.ts"],
-  "sourcesContent": ["import type { EntityManager } from '@mikro-orm/postgresql'\nimport * as fs from 'fs'\nimport * as path from 'path'\nimport { fileURLToPath } from 'node:url'\nimport { WorkflowDefinition, type WorkflowDefinitionData } from '../data/entities'\nimport { BusinessRule, type RuleType } from '@open-mercato/core/modules/business_rules/data/entities'\nimport {\n  invalidateBusinessRuleDiscoveryCache,\n  type RuleDiscoveryCache,\n} from '@open-mercato/core/modules/business_rules/lib/rule-engine'\nimport { createLogger } from '@open-mercato/shared/lib/logger'\n\nconst logger = createLogger('workflows')\n\nconst __esmDirname = path.dirname(fileURLToPath(import.meta.url))\n\nexport type WorkflowSeedScope = { tenantId: string; organizationId: string }\n\ntype WorkflowSeedDefinition = {\n  workflowId: string\n  workflowName: string\n  description?: string | null\n  version?: number\n  definition: WorkflowDefinitionData\n  metadata?: Record<string, unknown> | null\n  enabled?: boolean\n  effectiveFrom?: string | null\n  effectiveTo?: string | null\n  createdBy?: string | null\n  updatedBy?: string | null\n}\n\ntype GuardRuleSeed = {\n  ruleId: string\n  ruleName: string\n  ruleType: RuleType\n  entityType: string\n  conditionExpression: unknown\n  eventType?: string | null\n  ruleCategory?: string | null\n  description?: string | null\n  successActions?: unknown\n  failureActions?: unknown\n  enabled?: boolean\n  priority?: number\n  version?: number\n  effectiveFrom?: string | null\n  effectiveTo?: string | null\n  createdBy?: string | null\n  updatedBy?: string | null\n  tagsJson?: string[]\n  labelsJson?: Record<string, string>\n}\n\nfunction readExampleJson<T>(fileName: string): T {\n  const candidates = [\n    path.join(__esmDirname, '..', 'examples', fileName),\n    path.join(process.cwd(), 'packages', 'core', 'src', 'modules', 'workflows', 'examples', fileName),\n    path.join(process.cwd(), 'src', 'modules', 'workflows', 'examples', fileName),\n  ]\n  const filePath = candidates.find((candidate) => fs.existsSync(candidate))\n  if (!filePath) {\n    throw new Error(`Missing workflow seed file: ${fileName}`)\n  }\n  return JSON.parse(fs.readFileSync(filePath, 'utf8')) as T\n}\n\nfunction requireString(value: unknown, label: string): string {\n  if (typeof value === 'string' && value.trim().length > 0) return value\n  throw new Error(`Invalid ${label} in workflow seed data.`)\n}\n\nasync function seedWorkflowDefinition(\n  em: EntityManager,\n  scope: WorkflowSeedScope,\n  fileName: string,\n): Promise<boolean> {\n  const seed = readExampleJson<WorkflowSeedDefinition>(fileName)\n  const workflowId = requireString(seed.workflowId, 'workflowId')\n\n  const existing = await em.findOne(WorkflowDefinition, {\n    workflowId,\n    tenantId: scope.tenantId,\n    organizationId: scope.organizationId,\n  })\n\n  if (existing) {\n    // Check if the definition needs to be updated by comparing steps and transitions\n    const seedStepCount = seed.definition.steps.length\n    const existingStepCount = existing.definition.steps.length\n    const seedTransitionCount = seed.definition.transitions.length\n    const existingTransitionCount = existing.definition.transitions.length\n\n    // Check for preConditions on transitions\n    const seedHasTransitionPreConditions = seed.definition.transitions.some(\n      (t: any) => t.preConditions && t.preConditions.length > 0\n    )\n    const existingHasTransitionPreConditions = existing.definition.transitions.some(\n      (t: any) => t.preConditions && t.preConditions.length > 0\n    )\n\n    // Check for preConditions on START step\n    const seedStartStep = seed.definition.steps.find((s: any) => s.stepType === 'START')\n    const existingStartStep = existing.definition.steps.find((s: any) => s.stepType === 'START')\n    const seedHasStartPreConditions = seedStartStep?.preConditions && seedStartStep.preConditions.length > 0\n    const existingHasStartPreConditions = existingStartStep?.preConditions && existingStartStep.preConditions.length > 0\n\n    // Update if structure has changed\n    const needsUpdate =\n      seedStepCount !== existingStepCount ||\n      seedTransitionCount !== existingTransitionCount ||\n      (seedHasStartPreConditions && !existingHasStartPreConditions) ||\n      (seedHasTransitionPreConditions && !existingHasTransitionPreConditions)\n\n    if (needsUpdate) {\n      logger.info('Updating seeded workflow', {\n        component: 'seed',\n        workflowId,\n        existingStepCount,\n        seedStepCount,\n        existingTransitionCount,\n        seedTransitionCount,\n      })\n      existing.definition = seed.definition\n      await em.flush()\n      return true\n    }\n\n    return false\n  }\n\n  const workflow = em.create(WorkflowDefinition, {\n    ...seed,\n    workflowId,\n    tenantId: scope.tenantId,\n    organizationId: scope.organizationId,\n  })\n  em.persist(workflow)\n  await em.flush()\n  return true\n}\n\nasync function seedGuardRules(\n  em: EntityManager,\n  scope: WorkflowSeedScope,\n  fileName: string,\n  cache?: RuleDiscoveryCache | null,\n): Promise<{ seeded: number; skipped: number; updated: number }> {\n  const seeds = readExampleJson<GuardRuleSeed[]>(fileName)\n  if (!Array.isArray(seeds)) {\n    throw new Error('Invalid guard rules seed data.')\n  }\n\n  let seeded = 0\n  let skipped = 0\n  let updated = 0\n  for (const rule of seeds) {\n    const ruleId = requireString(rule.ruleId, 'ruleId')\n    const existing = await em.findOne(BusinessRule, {\n      ruleId,\n      tenantId: scope.tenantId,\n      organizationId: scope.organizationId,\n    })\n    if (existing) {\n      // Check if entityType or eventType needs updating\n      const needsUpdate = existing.entityType !== rule.entityType || existing.eventType !== rule.eventType\n      if (needsUpdate) {\n        logger.info('Updating seeded business rule', {\n          component: 'seed',\n          ruleId,\n          entityType: rule.entityType,\n          eventType: rule.eventType,\n        })\n        existing.entityType = rule.entityType\n        existing.eventType = rule.eventType ?? null\n        updated += 1\n      } else {\n        skipped += 1\n      }\n      continue\n    }\n    const entry = em.create(BusinessRule, {\n      ruleId,\n      ruleName: rule.ruleName,\n      ruleType: rule.ruleType,\n      entityType: rule.entityType,\n      conditionExpression: rule.conditionExpression,\n      eventType: rule.eventType,\n      ruleCategory: rule.ruleCategory,\n      description: rule.description,\n      successActions: rule.successActions,\n      failureActions: rule.failureActions,\n      enabled: rule.enabled,\n      priority: rule.priority,\n      version: rule.version,\n      effectiveFrom: rule.effectiveFrom,\n      effectiveTo: rule.effectiveTo,\n      createdBy: rule.createdBy,\n      updatedBy: rule.updatedBy,\n      tenantId: scope.tenantId,\n      organizationId: scope.organizationId,\n    })\n    em.persist(entry)\n    seeded += 1\n  }\n  if (seeded > 0 || updated > 0) {\n    await em.flush()\n    await invalidateBusinessRuleDiscoveryCache(cache, scope.tenantId, scope.organizationId)\n  }\n  return { seeded, skipped, updated }\n}\n\nexport async function seedExampleWorkflows(\n  em: EntityManager,\n  scope: WorkflowSeedScope,\n  options: { cache?: RuleDiscoveryCache | null } = {},\n): Promise<void> {\n  // workflows.checkout-demo and workflows.simple-approval are now code-defined\n  // (see packages/core/src/modules/workflows/workflows.ts). Seeding DB rows for\n  // them would shadow the code definitions in the merge layer, so they are no\n  // longer seeded here. Existing tenants are migrated via Migration20260428102318.\n  await seedGuardRules(em, scope, 'guard-rules-example.json', options.cache)\n  await seedWorkflowDefinition(em, scope, 'sales-pipeline-definition.json')\n  await seedGuardRules(em, scope, 'order-approval-guard-rules.json', options.cache)\n}\n"],
-  "mappings": "AACA,YAAY,QAAQ;AACpB,YAAY,UAAU;AACtB,SAAS,qBAAqB;AAC9B,SAAS,0BAAuD;AAChE,SAAS,oBAAmC;AAC5C;AAAA,EACE;AAAA,OAEK;AACP,SAAS,oBAAoB;AAE7B,MAAM,SAAS,aAAa,WAAW;AAEvC,MAAM,eAAe,KAAK,QAAQ,cAAc,YAAY,GAAG,CAAC;AAwChE,SAAS,gBAAmB,UAAqB;AAC/C,QAAM,aAAa;AAAA,IACjB,KAAK,KAAK,cAAc,MAAM,YAAY,QAAQ;AAAA,IAClD,KAAK,KAAK,QAAQ,IAAI,GAAG,YAAY,QAAQ,OAAO,WAAW,aAAa,YAAY,QAAQ;AAAA,IAChG,KAAK,KAAK,QAAQ,IAAI,GAAG,OAAO,WAAW,aAAa,YAAY,QAAQ;AAAA,EAC9E;AACA,QAAM,WAAW,WAAW,KAAK,CAAC,cAAc,GAAG,WAAW,SAAS,CAAC;AACxE,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,+BAA+B,QAAQ,EAAE;AAAA,EAC3D;AACA,SAAO,KAAK,MAAM,GAAG,aAAa,UAAU,MAAM,CAAC;AACrD;AAEA,SAAS,cAAc,OAAgB,OAAuB;AAC5D,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS,EAAG,QAAO;AACjE,QAAM,IAAI,MAAM,WAAW,KAAK,yBAAyB;AAC3D;AAEA,eAAe,uBACb,IACA,OACA,UACkB;AAClB,QAAM,OAAO,gBAAwC,QAAQ;AAC7D,QAAM,aAAa,cAAc,KAAK,YAAY,YAAY;AAE9D,QAAM,WAAW,MAAM,GAAG,QAAQ,oBAAoB;AAAA,IACpD;AAAA,IACA,UAAU,MAAM;AAAA,IAChB,gBAAgB,MAAM;AAAA,EACxB,CAAC;AAED,MAAI,UAAU;AAEZ,UAAM,gBAAgB,KAAK,WAAW,MAAM;AAC5C,UAAM,oBAAoB,SAAS,WAAW,MAAM;AACpD,UAAM,sBAAsB,KAAK,WAAW,YAAY;AACxD,UAAM,0BAA0B,SAAS,WAAW,YAAY;AAGhE,UAAM,iCAAiC,KAAK,WAAW,YAAY;AAAA,MACjE,CAAC,MAAW,EAAE,iBAAiB,EAAE,cAAc,SAAS;AAAA,IAC1D;AACA,UAAM,qCAAqC,SAAS,WAAW,YAAY;AAAA,MACzE,CAAC,MAAW,EAAE,iBAAiB,EAAE,cAAc,SAAS;AAAA,IAC1D;AAGA,UAAM,gBAAgB,KAAK,WAAW,MAAM,KAAK,CAAC,MAAW,EAAE,aAAa,OAAO;AACnF,UAAM,oBAAoB,SAAS,WAAW,MAAM,KAAK,CAAC,MAAW,EAAE,aAAa,OAAO;AAC3F,UAAM,4BAA4B,eAAe,iBAAiB,cAAc,cAAc,SAAS;AACvG,UAAM,gCAAgC,mBAAmB,iBAAiB,kBAAkB,cAAc,SAAS;AAGnH,UAAM,cACJ,kBAAkB,qBAClB,wBAAwB,2BACvB,6BAA6B,CAAC,iCAC9B,kCAAkC,CAAC;AAEtC,QAAI,aAAa;AACf,aAAO,KAAK,4BAA4B;AAAA,QACtC,WAAW;AAAA,QACX;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AACD,eAAS,aAAa,KAAK;AAC3B,YAAM,GAAG,MAAM;AACf,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,GAAG,OAAO,oBAAoB;AAAA,IAC7C,GAAG;AAAA,IACH;AAAA,IACA,UAAU,MAAM;AAAA,IAChB,gBAAgB,MAAM;AAAA,EACxB,CAAC;AACD,KAAG,QAAQ,QAAQ;AACnB,QAAM,GAAG,MAAM;AACf,SAAO;AACT;AAEA,eAAe,eACb,IACA,OACA,UACA,OAC+D;AAC/D,QAAM,QAAQ,gBAAiC,QAAQ;AACvD,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,UAAM,IAAI,MAAM,gCAAgC;AAAA,EAClD;AAEA,MAAI,SAAS;AACb,MAAI,UAAU;AACd,MAAI,UAAU;AACd,aAAW,QAAQ,OAAO;AACxB,UAAM,SAAS,cAAc,KAAK,QAAQ,QAAQ;AAClD,UAAM,WAAW,MAAM,GAAG,QAAQ,cAAc;AAAA,MAC9C;AAAA,MACA,UAAU,MAAM;AAAA,MAChB,gBAAgB,MAAM;AAAA,IACxB,CAAC;AACD,QAAI,UAAU;AAEZ,YAAM,cAAc,SAAS,eAAe,KAAK,cAAc,SAAS,cAAc,KAAK;AAC3F,UAAI,aAAa;AACf,eAAO,KAAK,iCAAiC;AAAA,UAC3C,WAAW;AAAA,UACX;AAAA,UACA,YAAY,KAAK;AAAA,UACjB,WAAW,KAAK;AAAA,QAClB,CAAC;AACD,iBAAS,aAAa,KAAK;AAC3B,iBAAS,YAAY,KAAK,aAAa;AACvC,mBAAW;AAAA,MACb,OAAO;AACL,mBAAW;AAAA,MACb;AACA;AAAA,IACF;AACA,UAAM,QAAQ,GAAG,OAAO,cAAc;AAAA,MACpC;AAAA,MACA,UAAU,KAAK;AAAA,MACf,UAAU,KAAK;AAAA,MACf,YAAY,KAAK;AAAA,MACjB,qBAAqB,KAAK;AAAA,MAC1B,WAAW,KAAK;AAAA,MAChB,cAAc,KAAK;AAAA,MACnB,aAAa,KAAK;AAAA,MAClB,gBAAgB,KAAK;AAAA,MACrB,gBAAgB,KAAK;AAAA,MACrB,SAAS,KAAK;AAAA,MACd,UAAU,KAAK;AAAA,MACf,SAAS,KAAK;AAAA,MACd,eAAe,KAAK;AAAA,MACpB,aAAa,KAAK;AAAA,MAClB,WAAW,KAAK;AAAA,MAChB,WAAW,KAAK;AAAA,MAChB,UAAU,MAAM;AAAA,MAChB,gBAAgB,MAAM;AAAA,IACxB,CAAC;AACD,OAAG,QAAQ,KAAK;AAChB,cAAU;AAAA,EACZ;AACA,MAAI,SAAS,KAAK,UAAU,GAAG;AAC7B,UAAM,GAAG,MAAM;AACf,UAAM,qCAAqC,OAAO,MAAM,UAAU,MAAM,cAAc;AAAA,EACxF;AACA,SAAO,EAAE,QAAQ,SAAS,QAAQ;AACpC;AAEA,eAAsB,qBACpB,IACA,OACA,UAAiD,CAAC,GACnC;AAKf,QAAM,eAAe,IAAI,OAAO,4BAA4B,QAAQ,KAAK;AACzE,QAAM,uBAAuB,IAAI,OAAO,gCAAgC;AACxE,QAAM,eAAe,IAAI,OAAO,mCAAmC,QAAQ,KAAK;AAClF;",
+  "sourcesContent": ["import type { EntityManager } from '@mikro-orm/postgresql'\nimport * as fs from 'fs'\nimport * as path from 'path'\nimport { fileURLToPath } from 'node:url'\nimport { WorkflowDefinition, type WorkflowDefinitionData } from '../data/entities'\nimport { BusinessRule, type RuleType } from '@open-mercato/core/modules/business_rules/data/entities'\nimport {\n  invalidateBusinessRuleDiscoveryCache,\n  type RuleDiscoveryCache,\n} from '@open-mercato/core/modules/business_rules/lib/rule-engine'\nimport { createLogger } from '@open-mercato/shared/lib/logger'\n\nconst logger = createLogger('workflows')\n\nconst __esmDirname = path.dirname(fileURLToPath(import.meta.url))\n\nexport type WorkflowSeedScope = { tenantId: string; organizationId: string }\n\ntype WorkflowSeedDefinition = {\n  workflowId: string\n  workflowName: string\n  description?: string | null\n  version?: number\n  definition: WorkflowDefinitionData\n  metadata?: Record<string, unknown> | null\n  enabled?: boolean\n  effectiveFrom?: string | null\n  effectiveTo?: string | null\n  createdBy?: string | null\n  updatedBy?: string | null\n}\n\ntype GuardRuleSeed = {\n  ruleId: string\n  ruleName: string\n  ruleType: RuleType\n  entityType: string\n  conditionExpression: unknown\n  eventType?: string | null\n  ruleCategory?: string | null\n  description?: string | null\n  successActions?: unknown\n  failureActions?: unknown\n  enabled?: boolean\n  priority?: number\n  version?: number\n  effectiveFrom?: string | null\n  effectiveTo?: string | null\n  createdBy?: string | null\n  updatedBy?: string | null\n  tagsJson?: string[]\n  labelsJson?: Record<string, string>\n}\n\nfunction readExampleJson<T>(fileName: string): T {\n  const candidates = [\n    path.join(__esmDirname, '..', 'examples', fileName),\n    path.join(process.cwd(), 'packages', 'core', 'src', 'modules', 'workflows', 'examples', fileName),\n    path.join(process.cwd(), 'src', 'modules', 'workflows', 'examples', fileName),\n  ]\n  const filePath = candidates.find((candidate) => fs.existsSync(candidate))\n  if (!filePath) {\n    throw new Error(`Missing workflow seed file: ${fileName}`)\n  }\n  return JSON.parse(fs.readFileSync(filePath, 'utf8')) as T\n}\n\nfunction requireString(value: unknown, label: string): string {\n  if (typeof value === 'string' && value.trim().length > 0) return value\n  throw new Error(`Invalid ${label} in workflow seed data.`)\n}\n\nasync function seedWorkflowDefinition(\n  em: EntityManager,\n  scope: WorkflowSeedScope,\n  fileName: string,\n): Promise<boolean> {\n  const seed = readExampleJson<WorkflowSeedDefinition>(fileName)\n  const workflowId = requireString(seed.workflowId, 'workflowId')\n\n  // Version-aware: pin to the latest version so re-seeding never updates an\n  // older coexisting version row (workflowId is no longer unique per tenant).\n  const existing = await em.findOne(WorkflowDefinition, {\n    workflowId,\n    tenantId: scope.tenantId,\n    organizationId: scope.organizationId,\n  }, { orderBy: { version: 'DESC' } })\n\n  if (existing) {\n    // Check if the definition needs to be updated by comparing steps and transitions\n    const seedStepCount = seed.definition.steps.length\n    const existingStepCount = existing.definition.steps.length\n    const seedTransitionCount = seed.definition.transitions.length\n    const existingTransitionCount = existing.definition.transitions.length\n\n    // Check for preConditions on transitions\n    const seedHasTransitionPreConditions = seed.definition.transitions.some(\n      (t: any) => t.preConditions && t.preConditions.length > 0\n    )\n    const existingHasTransitionPreConditions = existing.definition.transitions.some(\n      (t: any) => t.preConditions && t.preConditions.length > 0\n    )\n\n    // Check for preConditions on START step\n    const seedStartStep = seed.definition.steps.find((s: any) => s.stepType === 'START')\n    const existingStartStep = existing.definition.steps.find((s: any) => s.stepType === 'START')\n    const seedHasStartPreConditions = seedStartStep?.preConditions && seedStartStep.preConditions.length > 0\n    const existingHasStartPreConditions = existingStartStep?.preConditions && existingStartStep.preConditions.length > 0\n\n    // Update if structure has changed\n    const needsUpdate =\n      seedStepCount !== existingStepCount ||\n      seedTransitionCount !== existingTransitionCount ||\n      (seedHasStartPreConditions && !existingHasStartPreConditions) ||\n      (seedHasTransitionPreConditions && !existingHasTransitionPreConditions)\n\n    if (needsUpdate) {\n      logger.info('Updating seeded workflow', {\n        component: 'seed',\n        workflowId,\n        existingStepCount,\n        seedStepCount,\n        existingTransitionCount,\n        seedTransitionCount,\n      })\n      existing.definition = seed.definition\n      await em.flush()\n      return true\n    }\n\n    return false\n  }\n\n  const workflow = em.create(WorkflowDefinition, {\n    ...seed,\n    workflowId,\n    tenantId: scope.tenantId,\n    organizationId: scope.organizationId,\n  })\n  em.persist(workflow)\n  await em.flush()\n  return true\n}\n\nasync function seedGuardRules(\n  em: EntityManager,\n  scope: WorkflowSeedScope,\n  fileName: string,\n  cache?: RuleDiscoveryCache | null,\n): Promise<{ seeded: number; skipped: number; updated: number }> {\n  const seeds = readExampleJson<GuardRuleSeed[]>(fileName)\n  if (!Array.isArray(seeds)) {\n    throw new Error('Invalid guard rules seed data.')\n  }\n\n  let seeded = 0\n  let skipped = 0\n  let updated = 0\n  for (const rule of seeds) {\n    const ruleId = requireString(rule.ruleId, 'ruleId')\n    const existing = await em.findOne(BusinessRule, {\n      ruleId,\n      tenantId: scope.tenantId,\n      organizationId: scope.organizationId,\n    })\n    if (existing) {\n      // Check if entityType or eventType needs updating\n      const needsUpdate = existing.entityType !== rule.entityType || existing.eventType !== rule.eventType\n      if (needsUpdate) {\n        logger.info('Updating seeded business rule', {\n          component: 'seed',\n          ruleId,\n          entityType: rule.entityType,\n          eventType: rule.eventType,\n        })\n        existing.entityType = rule.entityType\n        existing.eventType = rule.eventType ?? null\n        updated += 1\n      } else {\n        skipped += 1\n      }\n      continue\n    }\n    const entry = em.create(BusinessRule, {\n      ruleId,\n      ruleName: rule.ruleName,\n      ruleType: rule.ruleType,\n      entityType: rule.entityType,\n      conditionExpression: rule.conditionExpression,\n      eventType: rule.eventType,\n      ruleCategory: rule.ruleCategory,\n      description: rule.description,\n      successActions: rule.successActions,\n      failureActions: rule.failureActions,\n      enabled: rule.enabled,\n      priority: rule.priority,\n      version: rule.version,\n      effectiveFrom: rule.effectiveFrom,\n      effectiveTo: rule.effectiveTo,\n      createdBy: rule.createdBy,\n      updatedBy: rule.updatedBy,\n      tenantId: scope.tenantId,\n      organizationId: scope.organizationId,\n    })\n    em.persist(entry)\n    seeded += 1\n  }\n  if (seeded > 0 || updated > 0) {\n    await em.flush()\n    await invalidateBusinessRuleDiscoveryCache(cache, scope.tenantId, scope.organizationId)\n  }\n  return { seeded, skipped, updated }\n}\n\nexport async function seedExampleWorkflows(\n  em: EntityManager,\n  scope: WorkflowSeedScope,\n  options: { cache?: RuleDiscoveryCache | null } = {},\n): Promise<void> {\n  // workflows.checkout-demo and workflows.simple-approval are now code-defined\n  // (see packages/core/src/modules/workflows/workflows.ts). Seeding DB rows for\n  // them would shadow the code definitions in the merge layer, so they are no\n  // longer seeded here. Existing tenants are migrated via Migration20260428102318.\n  await seedGuardRules(em, scope, 'guard-rules-example.json', options.cache)\n  await seedWorkflowDefinition(em, scope, 'sales-pipeline-definition.json')\n  await seedGuardRules(em, scope, 'order-approval-guard-rules.json', options.cache)\n}\n"],
+  "mappings": "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",
   "names": []
 }