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

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

@@ -0,0 +1,158 @@
+import {
+  resolveStepFailureHandling
+} from "./error-routing.js";
+const OUTCOME_TRANSITION_KIND = "outcome";
+const AGENT_OUTCOME_KINDS = [
+  "approved",
+  "researcher",
+  "rejected",
+  "guardrailBlocked",
+  "error"
+];
+const OUTCOME_SOURCE_HANDLE_PREFIX = "outcome:";
+const WORKFLOW_AGENT_OUTCOME_CONTEXT_KEY = "__agentOutcome";
+function buildAgentOutcomeContextEntry(stepId, outcome, proposalId) {
+  return {
+    stepId,
+    outcome,
+    occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...proposalId ? { proposalId } : {}
+  };
+}
+function isAgentOutcomeKind(value) {
+  return typeof value === "string" && AGENT_OUTCOME_KINDS.includes(value);
+}
+function outcomeSourceHandleId(outcome) {
+  return `${OUTCOME_SOURCE_HANDLE_PREFIX}${outcome}`;
+}
+function parseOutcomeSourceHandleId(handleId) {
+  if (typeof handleId !== "string" || !handleId.startsWith(OUTCOME_SOURCE_HANDLE_PREFIX)) return null;
+  const candidate = handleId.slice(OUTCOME_SOURCE_HANDLE_PREFIX.length);
+  return isAgentOutcomeKind(candidate) ? candidate : null;
+}
+function isOutcomeTransition(transition) {
+  return transition?.kind === OUTCOME_TRANSITION_KIND;
+}
+function excludeOutcomeTransitions(transitions) {
+  return transitions.filter((transition) => !isOutcomeTransition(transition));
+}
+function readTransitionOutcomeKind(transition) {
+  if (!isOutcomeTransition(transition)) return null;
+  return isAgentOutcomeKind(transition?.outcomeKind) ? transition.outcomeKind : null;
+}
+function listWiredOutcomes(definition, stepId) {
+  const wired = /* @__PURE__ */ new Set();
+  for (const transition of definition?.transitions ?? []) {
+    if (transition.fromStepId !== stepId) continue;
+    const outcome = readTransitionOutcomeKind(transition);
+    if (outcome) wired.add(outcome);
+  }
+  return AGENT_OUTCOME_KINDS.filter((outcome) => wired.has(outcome));
+}
+function findOutcomeTransition(definition, stepId, outcome) {
+  const candidates = (definition?.transitions ?? []).filter(
+    (transition) => transition.fromStepId === stepId && readTransitionOutcomeKind(transition) === outcome
+  );
+  if (candidates.length === 0) return null;
+  const ordered = [...candidates].sort((left, right) => (right.priority || 0) - (left.priority || 0));
+  return ordered[0] ?? null;
+}
+function resolveAgentOutcomeHandling(definition, stepId, outcome) {
+  if (listWiredOutcomes(definition, stepId).length === 0) return { kind: "default" };
+  const wired = findOutcomeTransition(definition, stepId, outcome);
+  if (wired) return { kind: "route", outcome, transition: wired };
+  if (outcome === "approved") return { kind: "default" };
+  return { kind: "inherit", outcome, handling: resolveStepFailureHandling(definition, stepId) };
+}
+const DISPOSITION_TO_OUTCOME = {
+  auto_approved: "approved",
+  approved: "approved",
+  edited: "approved",
+  researcher: "researcher",
+  none_proposed: "researcher",
+  artifact: "researcher",
+  rejected: "rejected",
+  guardrail_blocked: "guardrailBlocked",
+  guardrailBlocked: "guardrailBlocked"
+};
+function mapDispositionToAgentOutcome(disposition) {
+  if (typeof disposition !== "string") return null;
+  return DISPOSITION_TO_OUTCOME[disposition] ?? null;
+}
+function isGuardrailBlockedError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const tagged = error;
+  return tagged.code === "agent_guardrail_blocked" || tagged.guardrailBlocked === true;
+}
+function readGuardrailBlockEvidenceRef(error) {
+  if (typeof error !== "object" || error === null) return {};
+  const tagged = error;
+  const pick = (key) => typeof tagged[key] === "string" ? tagged[key] : void 0;
+  return {
+    ...pick("phase") ? { phase: pick("phase") } : {},
+    ...pick("kind") ? { kind: pick("kind") } : {},
+    ...pick("guardrailSetVersion") ? { guardrailSetVersion: pick("guardrailSetVersion") } : {},
+    ...pick("checkId") ? { checkId: pick("checkId") } : {}
+  };
+}
+const WORKFLOW_GUARDRAIL_BLOCK_CONTEXT_KEY = "__guardrailBlock";
+function readAgentOutcomeMarker(context, stepId) {
+  const raw = context?.[WORKFLOW_AGENT_OUTCOME_CONTEXT_KEY];
+  if (!raw || typeof raw !== "object") return null;
+  const entry = raw;
+  if (entry.stepId !== stepId) return null;
+  if (!isAgentOutcomeKind(entry.outcome)) return null;
+  return entry;
+}
+function validateOutcomeRoutes(definition) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const transition of definition?.transitions ?? []) {
+    if (!isOutcomeTransition(transition)) continue;
+    const outcome = readTransitionOutcomeKind(transition);
+    if (!outcome) {
+      issues.push({
+        code: "OUTCOME_ROUTE_UNKNOWN_KIND",
+        message: `Outcome route ${transition.transitionId ?? ""} claims outcome "${transition.outcomeKind ?? ""}", which is not one of ${AGENT_OUTCOME_KINDS.join(", ")}`,
+        transitionId: transition.transitionId,
+        stepId: transition.fromStepId
+      });
+      continue;
+    }
+    const key = `${transition.fromStepId ?? ""}::${outcome}`;
+    const count = (seen.get(key) ?? 0) + 1;
+    seen.set(key, count);
+    if (count > 1) {
+      issues.push({
+        code: "OUTCOME_ROUTE_DUPLICATE_KIND",
+        message: `Step ${transition.fromStepId ?? ""} has more than one route for the "${outcome}" outcome`,
+        transitionId: transition.transitionId,
+        stepId: transition.fromStepId
+      });
+    }
+  }
+  return issues;
+}
+export {
+  AGENT_OUTCOME_KINDS,
+  OUTCOME_SOURCE_HANDLE_PREFIX,
+  OUTCOME_TRANSITION_KIND,
+  WORKFLOW_AGENT_OUTCOME_CONTEXT_KEY,
+  WORKFLOW_GUARDRAIL_BLOCK_CONTEXT_KEY,
+  buildAgentOutcomeContextEntry,
+  excludeOutcomeTransitions,
+  findOutcomeTransition,
+  isAgentOutcomeKind,
+  isGuardrailBlockedError,
+  isOutcomeTransition,
+  listWiredOutcomes,
+  mapDispositionToAgentOutcome,
+  outcomeSourceHandleId,
+  parseOutcomeSourceHandleId,
+  readAgentOutcomeMarker,
+  readGuardrailBlockEvidenceRef,
+  readTransitionOutcomeKind,
+  resolveAgentOutcomeHandling,
+  validateOutcomeRoutes
+};
+//# sourceMappingURL=outcome-routing.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/outcome-routing.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - Agent outcome routing (pure)\n *\n * Resolves where a run goes once an INVOKE_AGENT step has a disposition, from\n * the definition alone \u2014 the third member of the family `lib/error-routing.ts`\n * and `lib/breach-routing.ts` belong to, and shaped like them on purpose.\n *\n * Spec \u00A77.2: the agent node exposes labelled output handles for a FIXED\n * platform vocabulary of five disposition kinds \u2014 `approved`, `researcher`,\n * `rejected`, `guardrailBlocked`, `error` \u2014 and branching on a disposition is\n * WIRING. The alternative, enumerating handles from the selected agent's OUTCOME\n * schema, is deliberately NOT built: it would need a per-value condition on each\n * transition, which is exactly the context string-matching \u00A77.2 exists to\n * remove. These five are governance states, not domain data.\n *\n * Precedence, per \u00A77.2's progressive-disclosure rule:\n *\n *   1. the step declares NO outcome route at all \u21D2 `default` \u2014 normal routing,\n *      byte-identical to how every definition written before this feature runs;\n *   2. an outgoing `kind: 'outcome'` route whose `outcomeKind` matches wins;\n *   3. `approved` unwired \u21D2 `default`. \u00A77.2 renders `approved` as always\n *      present (\"only wired handles PLUS `approved`\") because the node's default\n *      output IS the approved path \u2014 inheriting the error directive for it would\n *      fail runs whose agent simply succeeded;\n *   4. any other unwired outcome \u21D2 `inherit`, the node's error directive, which\n *      is the inheritance \u00A77.2 asks the node face to state\n *      (\"unhandled \u2192 fail instance\").\n *\n * Rule 1 is what keeps this additive: without it, adding one `rejected` route\n * to a step would silently change what an `researcher` result does.\n *\n * PURE: no ORM, DI, React or registry imports. Engine call sites pass the plain\n * definition JSON.\n */\n\nimport {\n  resolveStepFailureHandling,\n  type ErrorRoutingDefinitionLike,\n  type StepFailureHandling,\n} from './error-routing'\n\nexport const OUTCOME_TRANSITION_KIND = 'outcome'\n\n/**\n * The five fixed disposition kinds of spec \u00A77.2. Ordered as the node renders\n * them: the happy path first, escalations after, the infra failure last.\n */\nexport const AGENT_OUTCOME_KINDS = [\n  'approved',\n  'researcher',\n  'rejected',\n  'guardrailBlocked',\n  'error',\n] as const\n\nexport type AgentOutcomeKind = (typeof AGENT_OUTCOME_KINDS)[number]\n\n/**\n * Canvas source handle ids, one per outcome \u2014 `outcome:approved` and friends.\n * Namespaced so the handle set can grow without colliding with the default\n * handle, `ERROR_SOURCE_HANDLE_ID` or `SLA_BREACH_SOURCE_HANDLE_ID`.\n */\nexport const OUTCOME_SOURCE_HANDLE_PREFIX = 'outcome:'\n\n/**\n * Run-context key carrying the disposition an agent step resolved to, so the\n * executor can route on it. ENGINE-OWNED and reserved against user context\n * writes, exactly like `WORKFLOW_ERROR_CONTEXT_KEY`: routing never reads the\n * author-visible `disposition` key, which is what makes this wiring rather than\n * string-matching.\n */\nexport const WORKFLOW_AGENT_OUTCOME_CONTEXT_KEY = '__agentOutcome'\n\nexport interface WorkflowAgentOutcomeContextEntry {\n  stepId: string\n  outcome: AgentOutcomeKind\n  occurredAt: string\n  proposalId?: string\n}\n\nexport function buildAgentOutcomeContextEntry(\n  stepId: string,\n  outcome: AgentOutcomeKind,\n  proposalId?: string,\n): WorkflowAgentOutcomeContextEntry {\n  return {\n    stepId,\n    outcome,\n    occurredAt: new Date().toISOString(),\n    ...(proposalId ? { proposalId } : {}),\n  }\n}\n\nexport function isAgentOutcomeKind(value: unknown): value is AgentOutcomeKind {\n  return typeof value === 'string' && (AGENT_OUTCOME_KINDS as readonly string[]).includes(value)\n}\n\nexport function outcomeSourceHandleId(outcome: AgentOutcomeKind): string {\n  return `${OUTCOME_SOURCE_HANDLE_PREFIX}${outcome}`\n}\n\nexport function parseOutcomeSourceHandleId(handleId: unknown): AgentOutcomeKind | null {\n  if (typeof handleId !== 'string' || !handleId.startsWith(OUTCOME_SOURCE_HANDLE_PREFIX)) return null\n  const candidate = handleId.slice(OUTCOME_SOURCE_HANDLE_PREFIX.length)\n  return isAgentOutcomeKind(candidate) ? candidate : null\n}\n\nexport interface OutcomeRoutingTransitionLike {\n  transitionId?: string\n  fromStepId?: string\n  toStepId?: string\n  kind?: string\n  outcomeKind?: string\n  priority?: number\n}\n\nexport interface OutcomeRoutingDefinitionLike extends ErrorRoutingDefinitionLike {\n  transitions?: OutcomeRoutingTransitionLike[]\n}\n\nexport type AgentOutcomeHandling =\n  | { kind: 'route'; outcome: AgentOutcomeKind; transition: OutcomeRoutingTransitionLike }\n  | { kind: 'inherit'; outcome: AgentOutcomeKind; handling: StepFailureHandling }\n  | { kind: 'default' }\n\nexport function isOutcomeTransition(\n  transition: OutcomeRoutingTransitionLike | null | undefined,\n): boolean {\n  return transition?.kind === OUTCOME_TRANSITION_KIND\n}\n\n/**\n * Outcome routes must never be taken by normal routing \u2014 they are reachable only\n * from a resolved disposition, exactly like error and SLA-breach routes. Every\n * routing lookup filters through this helper.\n */\nexport function excludeOutcomeTransitions<T extends OutcomeRoutingTransitionLike>(\n  transitions: T[],\n): T[] {\n  return transitions.filter((transition) => !isOutcomeTransition(transition))\n}\n\n/** The outcome a route claims, or null when it claims none the platform knows. */\nexport function readTransitionOutcomeKind(\n  transition: OutcomeRoutingTransitionLike | null | undefined,\n): AgentOutcomeKind | null {\n  if (!isOutcomeTransition(transition)) return null\n  return isAgentOutcomeKind(transition?.outcomeKind) ? transition.outcomeKind : null\n}\n\n/** Every outcome a step has wired, in the platform's render order. */\nexport function listWiredOutcomes(\n  definition: OutcomeRoutingDefinitionLike | null | undefined,\n  stepId: string,\n): AgentOutcomeKind[] {\n  const wired = new Set<AgentOutcomeKind>()\n  for (const transition of definition?.transitions ?? []) {\n    if (transition.fromStepId !== stepId) continue\n    const outcome = readTransitionOutcomeKind(transition)\n    if (outcome) wired.add(outcome)\n  }\n  return AGENT_OUTCOME_KINDS.filter((outcome) => wired.has(outcome))\n}\n\n/**\n * Highest-priority outgoing route for one outcome. Ties keep definition order,\n * mirroring how `findValidTransitions` orders normal routes.\n */\nexport function findOutcomeTransition(\n  definition: OutcomeRoutingDefinitionLike | null | undefined,\n  stepId: string,\n  outcome: AgentOutcomeKind,\n): OutcomeRoutingTransitionLike | null {\n  const candidates = (definition?.transitions ?? []).filter(\n    (transition) =>\n      transition.fromStepId === stepId && readTransitionOutcomeKind(transition) === outcome,\n  )\n  if (candidates.length === 0) return null\n  const ordered = [...candidates].sort((left, right) => (right.priority || 0) - (left.priority || 0))\n  return ordered[0] ?? null\n}\n\n/**\n * The single decision point for a resolved agent disposition. See the module\n * docblock for the precedence and why `default` covers both \"nothing is wired\"\n * cases \u2014 it is the whole of the backward-compatibility guarantee.\n */\nexport function resolveAgentOutcomeHandling(\n  definition: OutcomeRoutingDefinitionLike | null | undefined,\n  stepId: string,\n  outcome: AgentOutcomeKind,\n): AgentOutcomeHandling {\n  if (listWiredOutcomes(definition, stepId).length === 0) return { kind: 'default' }\n\n  const wired = findOutcomeTransition(definition, stepId, outcome)\n  if (wired) return { kind: 'route', outcome, transition: wired }\n\n  if (outcome === 'approved') return { kind: 'default' }\n\n  return { kind: 'inherit', outcome, handling: resolveStepFailureHandling(definition, stepId) }\n}\n\n/**\n * Disposition vocabularies the platform speaks, mapped onto the \u00A77.2 five.\n *\n * `auto_approved` is the agent-envelope spelling of `approved`; `edited` is a\n * human approving a proposal they amended, which still executes, so it routes\n * the approved handle rather than inventing a sixth outcome the spec does not\n * define. `pending` maps to nothing \u2014 the step is still parked.\n *\n * `none_proposed` \u2014 an agent that looked and had nothing to propose \u2014 takes the\n * `researcher` handle, which is exactly what that route means. It is NOT\n * `rejected`: nothing was offered for a human to decline.\n *\n * `artifact` \u2014 an agent that PRODUCED a file \u2014 takes it for the same reason. The\n * five handles are a vocabulary of DECISIONS; making a document is not one, and\n * adding a sixth handle for it would fan every agent node on the canvas to say\n * nothing new about governance.\n */\nconst DISPOSITION_TO_OUTCOME: Record<string, AgentOutcomeKind> = {\n  auto_approved: 'approved',\n  approved: 'approved',\n  edited: 'approved',\n  researcher: 'researcher',\n  none_proposed: 'researcher',\n  artifact: 'researcher',\n  rejected: 'rejected',\n  guardrail_blocked: 'guardrailBlocked',\n  guardrailBlocked: 'guardrailBlocked',\n}\n\nexport function mapDispositionToAgentOutcome(disposition: unknown): AgentOutcomeKind | null {\n  if (typeof disposition !== 'string') return null\n  return DISPOSITION_TO_OUTCOME[disposition] ?? null\n}\n\n/**\n * Structural recognition of a runtime guardrail `block` (spec \u00A77.3).\n *\n * Shaped like `isRetryableError` in `activity-worker-handler`: core reads a tag\n * off the thrown value rather than importing `agent_orchestrator`, which stays\n * an OPTIONAL peer. `agent_guardrail_blocked` is the code\n * `AgentGuardrailBlockedError` carries; `guardrailBlocked: true` is the\n * forward-compatible tag any other runtime can set.\n */\nexport function isGuardrailBlockedError(error: unknown): boolean {\n  if (typeof error !== 'object' || error === null) return false\n  const tagged = error as { code?: unknown; guardrailBlocked?: unknown }\n  return tagged.code === 'agent_guardrail_blocked' || tagged.guardrailBlocked === true\n}\n\n/**\n * The guardrail facts safe to bind to a workflow route.\n *\n * `agent_orchestrator/AGENTS.md` requires guardrail evidence to be REDACTED \u2014\n * never raw PII \u2014 so only the classification travels: which phase tripped, which\n * check kind, and the guardrail-set version. The evidence blob itself stays on\n * the `AgentGuardrailCheck` row and is reached by id.\n */\nexport interface GuardrailBlockEvidenceRef {\n  phase?: string\n  kind?: string\n  guardrailSetVersion?: string\n  checkId?: string\n}\n\nexport function readGuardrailBlockEvidenceRef(error: unknown): GuardrailBlockEvidenceRef {\n  if (typeof error !== 'object' || error === null) return {}\n  const tagged = error as Record<string, unknown>\n  const pick = (key: string): string | undefined =>\n    typeof tagged[key] === 'string' ? (tagged[key] as string) : undefined\n  return {\n    ...(pick('phase') ? { phase: pick('phase') } : {}),\n    ...(pick('kind') ? { kind: pick('kind') } : {}),\n    ...(pick('guardrailSetVersion') ? { guardrailSetVersion: pick('guardrailSetVersion') } : {}),\n    ...(pick('checkId') ? { checkId: pick('checkId') } : {}),\n  }\n}\n\n/**\n * Context key the guardrail evidence REFERENCE lands under when a block takes\n * the guardrail route, so the review task the author wires can bind it.\n */\nexport const WORKFLOW_GUARDRAIL_BLOCK_CONTEXT_KEY = '__guardrailBlock'\n\n/** The engine-owned outcome marker for a step, or null when it names another step. */\nexport function readAgentOutcomeMarker(\n  context: Record<string, unknown> | null | undefined,\n  stepId: string,\n): WorkflowAgentOutcomeContextEntry | null {\n  const raw = context?.[WORKFLOW_AGENT_OUTCOME_CONTEXT_KEY]\n  if (!raw || typeof raw !== 'object') return null\n  const entry = raw as Partial<WorkflowAgentOutcomeContextEntry>\n  if (entry.stepId !== stepId) return null\n  if (!isAgentOutcomeKind(entry.outcome)) return null\n  return entry as WorkflowAgentOutcomeContextEntry\n}\n\nexport interface OutcomeRouteIssue {\n  code: 'OUTCOME_ROUTE_UNKNOWN_KIND' | 'OUTCOME_ROUTE_DUPLICATE_KIND'\n  message: string\n  transitionId?: string\n  stepId?: string\n}\n\n/**\n * Author-time checks surfaced by the Problems panel. An outcome route claiming a\n * kind the platform does not define is unreachable, and two routes claiming the\n * same kind make the destination depend on priority ties rather than on wiring \u2014\n * both are wiring mistakes the canvas cannot show.\n */\nexport function validateOutcomeRoutes(\n  definition: OutcomeRoutingDefinitionLike | null | undefined,\n): OutcomeRouteIssue[] {\n  const issues: OutcomeRouteIssue[] = []\n  const seen = new Map<string, number>()\n\n  for (const transition of definition?.transitions ?? []) {\n    if (!isOutcomeTransition(transition)) continue\n\n    const outcome = readTransitionOutcomeKind(transition)\n    if (!outcome) {\n      issues.push({\n        code: 'OUTCOME_ROUTE_UNKNOWN_KIND',\n        message: `Outcome route ${transition.transitionId ?? ''} claims outcome \"${transition.outcomeKind ?? ''}\", which is not one of ${AGENT_OUTCOME_KINDS.join(', ')}`,\n        transitionId: transition.transitionId,\n        stepId: transition.fromStepId,\n      })\n      continue\n    }\n\n    const key = `${transition.fromStepId ?? ''}::${outcome}`\n    const count = (seen.get(key) ?? 0) + 1\n    seen.set(key, count)\n    if (count > 1) {\n      issues.push({\n        code: 'OUTCOME_ROUTE_DUPLICATE_KIND',\n        message: `Step ${transition.fromStepId ?? ''} has more than one route for the \"${outcome}\" outcome`,\n        transitionId: transition.transitionId,\n        stepId: transition.fromStepId,\n      })\n    }\n  }\n\n  return issues\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/workflows/lib/owned-definition.js

@@ -0,0 +1,107 @@
+import { randomUUID } from "node:crypto";
+import {
+  WorkflowDefinition
+} from "../data/entities.js";
+import { normalizeGrantedFeatures, syncWorkflowDefinitionPrincipal } from "./definition-grant.js";
+import { invalidateTriggerCache } from "./event-trigger-service.js";
+function ownedBy(definition, ownerModule, ownerId) {
+  const generatedBy = definition.metadata?.generatedBy;
+  return !!generatedBy && generatedBy.module === ownerModule && generatedBy.ownerId === ownerId;
+}
+function createWorkflowDefinitionAuthoring(container) {
+  return {
+    async findOwnedDefinition(em, params) {
+      return em.findOne(
+        WorkflowDefinition,
+        {
+          workflowId: params.workflowId,
+          tenantId: params.tenantId,
+          organizationId: params.organizationId,
+          deletedAt: null
+        },
+        { orderBy: { version: "DESC" } }
+      );
+    },
+    async findDefinitionsByWorkflowIds(em, params) {
+      if (params.workflowIds.length === 0) return [];
+      return em.find(
+        WorkflowDefinition,
+        {
+          workflowId: { $in: params.workflowIds },
+          tenantId: params.tenantId,
+          organizationId: params.organizationId,
+          deletedAt: null
+        },
+        { orderBy: { version: "DESC" } }
+      );
+    },
+    async upsertOwnedDefinition(em, input) {
+      const grantedFeatures = normalizeGrantedFeatures(input.grantedFeatures);
+      const existing = await em.findOne(
+        WorkflowDefinition,
+        {
+          workflowId: input.workflowId,
+          tenantId: input.tenantId,
+          organizationId: input.organizationId,
+          deletedAt: null
+        },
+        { orderBy: { version: "DESC" } }
+      );
+      if (existing && !ownedBy(existing, input.ownerModule, input.ownerId)) {
+        return { ok: false, reason: "owned_by_other", definition: existing };
+      }
+      const metadata = {
+        ...input.metadata ?? {},
+        generatedBy: { module: input.ownerModule, ownerId: input.ownerId }
+      };
+      const definition = existing ?? em.create(WorkflowDefinition, {
+        // The PK is minted up front (MikroORM does not generate UUIDs
+        // client-side) so the execution principal — whose identity key is the
+        // definition id — can be provisioned BEFORE the row claiming the grant
+        // is persisted.
+        id: randomUUID(),
+        workflowId: input.workflowId,
+        workflowName: input.workflowName,
+        version: 1,
+        definition: input.definition,
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+        createdBy: input.actorUserId ?? null,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      definition.workflowName = input.workflowName;
+      definition.description = input.description ?? null;
+      definition.definition = input.definition;
+      definition.metadata = metadata;
+      definition.enabled = input.enabled ?? true;
+      definition.grantedFeatures = grantedFeatures.length ? grantedFeatures : null;
+      definition.updatedBy = input.actorUserId ?? definition.updatedBy ?? null;
+      definition.updatedAt = /* @__PURE__ */ new Date();
+      await syncWorkflowDefinitionPrincipal(container, definition);
+      em.persist(definition);
+      await em.flush();
+      invalidateTriggerCache(input.tenantId, input.organizationId);
+      return { ok: true, definition, created: !existing };
+    },
+    async deleteOwnedDefinition(em, params) {
+      const existing = await em.findOne(WorkflowDefinition, {
+        workflowId: params.workflowId,
+        tenantId: params.tenantId,
+        organizationId: params.organizationId,
+        deletedAt: null
+      });
+      if (!existing) return false;
+      if (!ownedBy(existing, params.ownerModule, params.ownerId)) return false;
+      existing.deletedAt = /* @__PURE__ */ new Date();
+      em.persist(existing);
+      await em.flush();
+      invalidateTriggerCache(params.tenantId, params.organizationId);
+      return true;
+    }
+  };
+}
+export {
+  createWorkflowDefinitionAuthoring
+};
+//# sourceMappingURL=owned-definition.js.map

package/dist/modules/workflows/lib/owned-definition.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/owned-definition.ts"],
+  "sourcesContent": ["import { randomUUID } from 'node:crypto'\nimport type { EntityManager } from '@mikro-orm/postgresql'\nimport type { AwilixContainer } from 'awilix'\nimport {\n  WorkflowDefinition,\n  type WorkflowDefinitionData,\n  type WorkflowMetadata,\n} from '../data/entities'\nimport { normalizeGrantedFeatures, syncWorkflowDefinitionPrincipal } from './definition-grant'\nimport { invalidateTriggerCache } from './event-trigger-service'\n\n/**\n * Create-or-update of a workflow definition that ANOTHER module authors and owns.\n *\n * The point of this service is that there is exactly one workflow engine and one\n * kind of workflow definition. When a module offers a simplified way to express a\n * process \u2014 \"run this agent every morning\" \u2014 the right answer is to generate a\n * real definition here, not to build a parallel executor for the simple case. The\n * generated row is an ordinary `WorkflowDefinition`: it shows up in the Studio,\n * it can be opened and extended by hand, and it runs through the same engine with\n * the same retry, wait, signal and cancellation semantics as anything else.\n *\n * Ownership is recorded in `metadata.generatedBy` and re-checked on every write,\n * so this can never silently take over a workflow a person authored or one\n * belonging to a different owner.\n *\n * Execution identity comes with it: `grantedFeatures` is applied through the same\n * `syncWorkflowDefinitionPrincipal` the definitions API uses, so a generated\n * workflow runs as its own least-privilege principal exactly like a hand-authored\n * one. AUTHORIZING that grant is the caller's job \u2014 this service is a write\n * primitive, not a permission boundary.\n */\n\nexport type OwnedWorkflowDefinitionInput = {\n  ownerModule: string\n  ownerId: string\n  workflowId: string\n  workflowName: string\n  description?: string | null\n  definition: WorkflowDefinitionData\n  metadata?: Omit<WorkflowMetadata, 'generatedBy'> | null\n  grantedFeatures?: string[] | null\n  enabled?: boolean\n  tenantId: string\n  organizationId: string\n  actorUserId?: string | null\n}\n\nexport type OwnedWorkflowDefinitionResult =\n  | { ok: true; definition: WorkflowDefinition; created: boolean }\n  | { ok: false; reason: 'owned_by_other'; definition: WorkflowDefinition }\n\nexport interface WorkflowDefinitionAuthoring {\n  upsertOwnedDefinition(\n    em: EntityManager,\n    input: OwnedWorkflowDefinitionInput,\n  ): Promise<OwnedWorkflowDefinitionResult>\n  findOwnedDefinition(\n    em: EntityManager,\n    params: { workflowId: string; tenantId: string; organizationId: string },\n  ): Promise<WorkflowDefinition | null>\n  /** Batch form for a list page: one query for a page of workflow ids. */\n  findDefinitionsByWorkflowIds(\n    em: EntityManager,\n    params: { workflowIds: string[]; tenantId: string; organizationId: string },\n  ): Promise<WorkflowDefinition[]>\n  deleteOwnedDefinition(\n    em: EntityManager,\n    params: { workflowId: string; ownerModule: string; ownerId: string; tenantId: string; organizationId: string },\n  ): Promise<boolean>\n}\n\nfunction ownedBy(definition: WorkflowDefinition, ownerModule: string, ownerId: string): boolean {\n  const generatedBy = definition.metadata?.generatedBy\n  return !!generatedBy && generatedBy.module === ownerModule && generatedBy.ownerId === ownerId\n}\n\nexport function createWorkflowDefinitionAuthoring(container: AwilixContainer): WorkflowDefinitionAuthoring {\n  return {\n    async findOwnedDefinition(em, params) {\n      return em.findOne(\n        WorkflowDefinition,\n        {\n          workflowId: params.workflowId,\n          tenantId: params.tenantId,\n          organizationId: params.organizationId,\n          deletedAt: null,\n        },\n        { orderBy: { version: 'DESC' } },\n      )\n    },\n\n    async findDefinitionsByWorkflowIds(em, params) {\n      if (params.workflowIds.length === 0) return []\n      return em.find(\n        WorkflowDefinition,\n        {\n          workflowId: { $in: params.workflowIds },\n          tenantId: params.tenantId,\n          organizationId: params.organizationId,\n          deletedAt: null,\n        },\n        { orderBy: { version: 'DESC' } },\n      )\n    },\n\n    async upsertOwnedDefinition(em, input) {\n      const grantedFeatures = normalizeGrantedFeatures(input.grantedFeatures)\n      const existing = await em.findOne(\n        WorkflowDefinition,\n        {\n          workflowId: input.workflowId,\n          tenantId: input.tenantId,\n          organizationId: input.organizationId,\n          deletedAt: null,\n        },\n        { orderBy: { version: 'DESC' } },\n      )\n\n      // A row that exists but belongs to someone else \u2014 a person's own workflow,\n      // or another owner's \u2014 is never overwritten. The caller decides what to do\n      // about it; silently replacing a hand-authored graph would be the worst\n      // possible failure mode of a convenience feature.\n      if (existing && !ownedBy(existing, input.ownerModule, input.ownerId)) {\n        return { ok: false, reason: 'owned_by_other', definition: existing }\n      }\n\n      const metadata: WorkflowMetadata = {\n        ...(input.metadata ?? {}),\n        generatedBy: { module: input.ownerModule, ownerId: input.ownerId },\n      }\n\n      const definition =\n        existing ??\n        em.create(WorkflowDefinition, {\n          // The PK is minted up front (MikroORM does not generate UUIDs\n          // client-side) so the execution principal \u2014 whose identity key is the\n          // definition id \u2014 can be provisioned BEFORE the row claiming the grant\n          // is persisted.\n          id: randomUUID(),\n          workflowId: input.workflowId,\n          workflowName: input.workflowName,\n          version: 1,\n          definition: input.definition,\n          tenantId: input.tenantId,\n          organizationId: input.organizationId,\n          createdBy: input.actorUserId ?? null,\n          createdAt: new Date(),\n          updatedAt: new Date(),\n        })\n\n      definition.workflowName = input.workflowName\n      definition.description = input.description ?? null\n      definition.definition = input.definition\n      definition.metadata = metadata\n      definition.enabled = input.enabled ?? true\n      definition.grantedFeatures = grantedFeatures.length ? grantedFeatures : null\n      definition.updatedBy = input.actorUserId ?? definition.updatedBy ?? null\n      definition.updatedAt = new Date()\n\n      await syncWorkflowDefinitionPrincipal(container, definition)\n      em.persist(definition)\n      await em.flush()\n\n      // Embedded triggers on a freshly written definition must be visible to the\n      // wildcard event subscriber immediately.\n      invalidateTriggerCache(input.tenantId, input.organizationId)\n\n      return { ok: true, definition, created: !existing }\n    },\n\n    async deleteOwnedDefinition(em, params) {\n      const existing = await em.findOne(WorkflowDefinition, {\n        workflowId: params.workflowId,\n        tenantId: params.tenantId,\n        organizationId: params.organizationId,\n        deletedAt: null,\n      })\n      if (!existing) return false\n      if (!ownedBy(existing, params.ownerModule, params.ownerId)) return false\n      existing.deletedAt = new Date()\n      em.persist(existing)\n      await em.flush()\n      invalidateTriggerCache(params.tenantId, params.organizationId)\n      return true\n    },\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/workflows/lib/owned-node-changes.js

@@ -0,0 +1,10 @@
+function filterOwnedNodeChanges(changes, ownedIds) {
+  return changes.filter((change) => {
+    const id = change.id;
+    return id === void 0 || ownedIds.has(id);
+  });
+}
+export {
+  filterOwnedNodeChanges
+};
+//# sourceMappingURL=owned-node-changes.js.map

package/dist/modules/workflows/lib/owned-node-changes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/owned-node-changes.ts"],
+  "sourcesContent": ["import type { NodeChange } from '@xyflow/react'\n\n/**\n * PURE. Keep only the ReactFlow node changes that target a node the editor\n * actually owns (i.e. a node in its controlled `nodes` state).\n *\n * WorkflowGraphImpl mints render-only overlay nodes \u2014 the trigger pill (fidelity\n * gap #5) \u2014 inside `canvasNodes` at render time; they are handed to ReactFlow\n * but never stored in node state. ReactFlow still measures such a node and emits\n * a `dimensions` change on every render. Applying that change via `setNodes`\n * schedules a re-render, which re-mints the overlay as a fresh object, which\n * ReactFlow re-measures \u2014 an unbounded loop that pins the CPU and starves node\n * dragging, so a dragged card never visibly tracks the cursor and only lands at\n * the drop point (the \"teleport\" bug). Dropping the overlay's changes here keeps\n * that batch from scheduling a re-render at all.\n *\n * Changes without an `id` (e.g. `add`, which carries `item` instead) are always\n * kept: they can only originate from the editor's own code, never from overlay\n * measurement.\n */\nexport function filterOwnedNodeChanges(\n  changes: NodeChange[],\n  ownedIds: ReadonlySet<string>,\n): NodeChange[] {\n  return changes.filter((change) => {\n    const id = (change as { id?: string }).id\n    return id === undefined || ownedIds.has(id)\n  })\n}\n"],
+  "mappings": "AAoBO,SAAS,uBACd,SACA,UACc;AACd,SAAO,QAAQ,OAAO,CAAC,WAAW;AAChC,UAAM,KAAM,OAA2B;AACvC,WAAO,OAAO,UAAa,SAAS,IAAI,EAAE;AAAA,EAC5C,CAAC;AACH;",
+  "names": []
+}

package/dist/modules/workflows/lib/palette-drag.js

@@ -0,0 +1,36 @@
+const WORKFLOW_PALETTE_DRAG_MIME = "application/x-om-workflow-palette";
+function writePaletteDragPayload(dataTransfer, item, label) {
+  dataTransfer.setData("text/plain", label);
+  dataTransfer.setData(WORKFLOW_PALETTE_DRAG_MIME, JSON.stringify(item));
+  dataTransfer.effectAllowed = "copy";
+}
+function parsePaletteDragItem(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const candidate = parsed;
+  if (candidate.kind === "step" && typeof candidate.nodeType === "string" && candidate.nodeType.length > 0) {
+    return { kind: "step", nodeType: candidate.nodeType };
+  }
+  if (candidate.kind === "activity" && typeof candidate.activityType === "string" && candidate.activityType.length > 0) {
+    return { kind: "activity", activityType: candidate.activityType };
+  }
+  return null;
+}
+function readPaletteDragItem(dataTransfer) {
+  if (!dataTransfer) return null;
+  if (Array.isArray(dataTransfer.types) && !dataTransfer.types.includes(WORKFLOW_PALETTE_DRAG_MIME)) return null;
+  const raw = dataTransfer.getData(WORKFLOW_PALETTE_DRAG_MIME);
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  return parsePaletteDragItem(raw);
+}
+export {
+  WORKFLOW_PALETTE_DRAG_MIME,
+  readPaletteDragItem,
+  writePaletteDragPayload
+};
+//# sourceMappingURL=palette-drag.js.map

package/dist/modules/workflows/lib/palette-drag.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/palette-drag.ts"],
+  "sourcesContent": ["/**\n * Palette drag transfer contract (spec section 4.2: \"Drag-from-palette drops at\n * the cursor; click appends for keyboard users\").\n *\n * A palette entry carries TWO payloads, the same way a ledger row does\n * (`lib/ledger-drag.ts`): a human-readable `text/plain` label so dropping\n * somewhere with no handler degrades to inserting text rather than doing\n * something surprising, and a private MIME carrying the machine payload the\n * canvas reads.\n *\n * Dragging is an ENHANCEMENT over the click path, never the only way in: every\n * palette entry stays a button, because the click path is the keyboard path.\n *\n * PURE and DOM-free: it reads a minimal `DataTransfer` shape, so the payload is\n * unit-testable without a real drag gesture (jsdom cannot perform one).\n */\n\nexport const WORKFLOW_PALETTE_DRAG_MIME = 'application/x-om-workflow-palette'\n\nexport type PaletteDragItem =\n  | { kind: 'step'; nodeType: string }\n  | { kind: 'activity'; activityType: string }\n\nexport interface PaletteDragDataTransfer {\n  getData: (type: string) => string\n  setData: (type: string, value: string) => void\n  types?: ReadonlyArray<string>\n  effectAllowed?: string\n}\n\nexport function writePaletteDragPayload(\n  dataTransfer: PaletteDragDataTransfer,\n  item: PaletteDragItem,\n  label: string,\n): void {\n  dataTransfer.setData('text/plain', label)\n  dataTransfer.setData(WORKFLOW_PALETTE_DRAG_MIME, JSON.stringify(item))\n  dataTransfer.effectAllowed = 'copy'\n}\n\nfunction parsePaletteDragItem(raw: string): PaletteDragItem | null {\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(raw)\n  } catch {\n    return null\n  }\n  if (!parsed || typeof parsed !== 'object') return null\n  const candidate = parsed as Record<string, unknown>\n  if (candidate.kind === 'step' && typeof candidate.nodeType === 'string' && candidate.nodeType.length > 0) {\n    return { kind: 'step', nodeType: candidate.nodeType }\n  }\n  if (candidate.kind === 'activity' && typeof candidate.activityType === 'string' && candidate.activityType.length > 0) {\n    return { kind: 'activity', activityType: candidate.activityType }\n  }\n  return null\n}\n\n/** The dragged palette entry, or null when the drag did not come from the palette. */\nexport function readPaletteDragItem(\n  dataTransfer: PaletteDragDataTransfer | null | undefined,\n): PaletteDragItem | null {\n  if (!dataTransfer) return null\n  if (Array.isArray(dataTransfer.types) && !dataTransfer.types.includes(WORKFLOW_PALETTE_DRAG_MIME)) return null\n  const raw = dataTransfer.getData(WORKFLOW_PALETTE_DRAG_MIME)\n  if (typeof raw !== 'string' || raw.length === 0) return null\n  return parsePaletteDragItem(raw)\n}\n"],
+  "mappings": "AAiBO,MAAM,6BAA6B;AAanC,SAAS,wBACd,cACA,MACA,OACM;AACN,eAAa,QAAQ,cAAc,KAAK;AACxC,eAAa,QAAQ,4BAA4B,KAAK,UAAU,IAAI,CAAC;AACrE,eAAa,gBAAgB;AAC/B;AAEA,SAAS,qBAAqB,KAAqC;AACjE,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,MAAM,GAAG;AAAA,EACzB,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI,CAAC,UAAU,OAAO,WAAW,SAAU,QAAO;AAClD,QAAM,YAAY;AAClB,MAAI,UAAU,SAAS,UAAU,OAAO,UAAU,aAAa,YAAY,UAAU,SAAS,SAAS,GAAG;AACxG,WAAO,EAAE,MAAM,QAAQ,UAAU,UAAU,SAAS;AAAA,EACtD;AACA,MAAI,UAAU,SAAS,cAAc,OAAO,UAAU,iBAAiB,YAAY,UAAU,aAAa,SAAS,GAAG;AACpH,WAAO,EAAE,MAAM,YAAY,cAAc,UAAU,aAAa;AAAA,EAClE;AACA,SAAO;AACT;AAGO,SAAS,oBACd,cACwB;AACxB,MAAI,CAAC,aAAc,QAAO;AAC1B,MAAI,MAAM,QAAQ,aAAa,KAAK,KAAK,CAAC,aAAa,MAAM,SAAS,0BAA0B,EAAG,QAAO;AAC1G,QAAM,MAAM,aAAa,QAAQ,0BAA0B;AAC3D,MAAI,OAAO,QAAQ,YAAY,IAAI,WAAW,EAAG,QAAO;AACxD,SAAO,qBAAqB,GAAG;AACjC;",
+  "names": []
+}

package/dist/modules/workflows/lib/palette-drop.js

@@ -0,0 +1,45 @@
+import { generateTransitionId } from "./graph-utils.js";
+import { isDataMappingEdge } from "./data-edge-mapping.js";
+import { buildWorkflowRouteEdge } from "./route-edge.js";
+function routeAt(edges, edgeId) {
+  return edges.find((edge) => edge.id === edgeId);
+}
+function insertStepOnRoute(nodes, edges, edgeId, newNode) {
+  const route = routeAt(edges, edgeId);
+  if (!route) return { ok: false, code: "unknownRoute" };
+  if (isDataMappingEdge(route)) return { ok: false, code: "dataMappingRoute" };
+  const continuation = buildWorkflowRouteEdge({
+    id: generateTransitionId(),
+    source: newNode.id,
+    target: route.target,
+    data: {
+      trigger: "auto",
+      preConditions: [],
+      postConditions: [],
+      activities: [],
+      label: ""
+    }
+  });
+  const nextEdges = edges.flatMap(
+    (edge) => edge.id === edgeId ? [{ ...edge, target: newNode.id, targetHandle: null }, continuation] : [edge]
+  );
+  return { ok: true, nodes: [...nodes, newNode], edges: nextEdges };
+}
+function appendActivityToRoute(edges, edgeId, activity) {
+  const route = routeAt(edges, edgeId);
+  if (!route) return { ok: false, code: "unknownRoute" };
+  if (isDataMappingEdge(route)) return { ok: false, code: "dataMappingRoute" };
+  const data = route.data ?? {};
+  const existing = Array.isArray(data.activities) ? data.activities : [];
+  return {
+    ok: true,
+    edges: edges.map(
+      (edge) => edge.id === edgeId ? { ...edge, data: { ...data, activities: [...existing, activity] } } : edge
+    )
+  };
+}
+export {
+  appendActivityToRoute,
+  insertStepOnRoute
+};
+//# sourceMappingURL=palette-drop.js.map

package/dist/modules/workflows/lib/palette-drop.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/palette-drop.ts"],
+  "sourcesContent": ["/**\n * What a palette drop does to the graph (spec sections 4.2 and 4.4).\n *\n * Two drop targets, two effects:\n * - a step dropped ON A ROUTE is spliced between that route's endpoints;\n * - an action dropped ON A ROUTE is appended to that route's activities, which\n *   is what the activity chips (#4244) then render.\n *\n * A step dropped on empty canvas is just an add at the cursor and needs nothing\n * from here \u2014 `lib/node-placement.ts` already resolves the position.\n *\n * **Insert-on-route keeps the original route's data on the FIRST segment**\n * (`from \u2192 new step`). A route's condition guards LEAVING its source step and\n * its activities run on the way out, so both belong to the segment that still\n * starts where the author put them; an error route likewise stays the error path\n * out of that step. Just as importantly, the durable `transitionId` is what\n * mid-flight state resolves against (`instance.pendingTransition`,\n * `WorkflowBranchInstance.branchKey`), so it must stay attached to the segment\n * that still leaves the same step. The second segment (`new step \u2192 to`) is a\n * fresh, unconditional auto route.\n *\n * PURE: plain graph data in, plain graph data out, machine-readable rejections\n * the editor translates.\n */\n\nimport type { Node, Edge } from '@xyflow/react'\nimport { generateTransitionId } from './graph-utils'\nimport { isDataMappingEdge } from './data-edge-mapping'\nimport { buildWorkflowRouteEdge } from './route-edge'\n\nexport type PaletteDropRejectionCode = 'unknownRoute' | 'dataMappingRoute'\n\nexport type PaletteDropRejection = { ok: false; code: PaletteDropRejectionCode }\n\nexport type InsertStepOnRouteResult =\n  | { ok: true; nodes: Node[]; edges: Edge[] }\n  | PaletteDropRejection\n\nexport type AppendActivityToRouteResult =\n  | { ok: true; edges: Edge[] }\n  | PaletteDropRejection\n\nexport interface RouteActivity {\n  activityId: string\n  activityName: string\n  activityType: string\n  config: Record<string, unknown>\n}\n\nfunction routeAt(edges: Edge[], edgeId: string): Edge | undefined {\n  return edges.find((edge) => edge.id === edgeId)\n}\n\n/**\n * Splice a new step into an existing route.\n *\n * The original transition is retargeted at the new step and keeps everything it\n * carried \u2014 id, label, condition, activities, priority, kind. A second,\n * unconditional route continues from the new step to the original target.\n */\nexport function insertStepOnRoute(\n  nodes: Node[],\n  edges: Edge[],\n  edgeId: string,\n  newNode: Node,\n): InsertStepOnRouteResult {\n  const route = routeAt(edges, edgeId)\n  if (!route) return { ok: false, code: 'unknownRoute' }\n  if (isDataMappingEdge(route)) return { ok: false, code: 'dataMappingRoute' }\n\n  const continuation: Edge = buildWorkflowRouteEdge({\n    id: generateTransitionId(),\n    source: newNode.id,\n    target: route.target,\n    data: {\n      trigger: 'auto',\n      preConditions: [],\n      postConditions: [],\n      activities: [],\n      label: '',\n    },\n  })\n\n  const nextEdges = edges.flatMap((edge) =>\n    edge.id === edgeId\n      ? [{ ...edge, target: newNode.id, targetHandle: null }, continuation]\n      : [edge],\n  )\n\n  return { ok: true, nodes: [...nodes, newNode], edges: nextEdges }\n}\n\n/** Append an action to a route's activity list (the chips render it). */\nexport function appendActivityToRoute(\n  edges: Edge[],\n  edgeId: string,\n  activity: RouteActivity,\n): AppendActivityToRouteResult {\n  const route = routeAt(edges, edgeId)\n  if (!route) return { ok: false, code: 'unknownRoute' }\n  if (isDataMappingEdge(route)) return { ok: false, code: 'dataMappingRoute' }\n\n  const data = (route.data ?? {}) as Record<string, unknown>\n  const existing = Array.isArray(data.activities) ? data.activities : []\n\n  return {\n    ok: true,\n    edges: edges.map((edge) =>\n      edge.id === edgeId\n        ? { ...edge, data: { ...data, activities: [...existing, activity] } }\n        : edge,\n    ),\n  }\n}\n"],
+  "mappings": "AA0BA,SAAS,4BAA4B;AACrC,SAAS,yBAAyB;AAClC,SAAS,8BAA8B;AAqBvC,SAAS,QAAQ,OAAe,QAAkC;AAChE,SAAO,MAAM,KAAK,CAAC,SAAS,KAAK,OAAO,MAAM;AAChD;AASO,SAAS,kBACd,OACA,OACA,QACA,SACyB;AACzB,QAAM,QAAQ,QAAQ,OAAO,MAAM;AACnC,MAAI,CAAC,MAAO,QAAO,EAAE,IAAI,OAAO,MAAM,eAAe;AACrD,MAAI,kBAAkB,KAAK,EAAG,QAAO,EAAE,IAAI,OAAO,MAAM,mBAAmB;AAE3E,QAAM,eAAqB,uBAAuB;AAAA,IAChD,IAAI,qBAAqB;AAAA,IACzB,QAAQ,QAAQ;AAAA,IAChB,QAAQ,MAAM;AAAA,IACd,MAAM;AAAA,MACJ,SAAS;AAAA,MACT,eAAe,CAAC;AAAA,MAChB,gBAAgB,CAAC;AAAA,MACjB,YAAY,CAAC;AAAA,MACb,OAAO;AAAA,IACT;AAAA,EACF,CAAC;AAED,QAAM,YAAY,MAAM;AAAA,IAAQ,CAAC,SAC/B,KAAK,OAAO,SACR,CAAC,EAAE,GAAG,MAAM,QAAQ,QAAQ,IAAI,cAAc,KAAK,GAAG,YAAY,IAClE,CAAC,IAAI;AAAA,EACX;AAEA,SAAO,EAAE,IAAI,MAAM,OAAO,CAAC,GAAG,OAAO,OAAO,GAAG,OAAO,UAAU;AAClE;AAGO,SAAS,sBACd,OACA,QACA,UAC6B;AAC7B,QAAM,QAAQ,QAAQ,OAAO,MAAM;AACnC,MAAI,CAAC,MAAO,QAAO,EAAE,IAAI,OAAO,MAAM,eAAe;AACrD,MAAI,kBAAkB,KAAK,EAAG,QAAO,EAAE,IAAI,OAAO,MAAM,mBAAmB;AAE3E,QAAM,OAAQ,MAAM,QAAQ,CAAC;AAC7B,QAAM,WAAW,MAAM,QAAQ,KAAK,UAAU,IAAI,KAAK,aAAa,CAAC;AAErE,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,OAAO,MAAM;AAAA,MAAI,CAAC,SAChB,KAAK,OAAO,SACR,EAAE,GAAG,MAAM,MAAM,EAAE,GAAG,MAAM,YAAY,CAAC,GAAG,UAAU,QAAQ,EAAE,EAAE,IAClE;AAAA,IACN;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/modules/workflows/lib/parallel-handler.js

@@ -8,7 +8,8 @@ import {
 } from "../data/entities.js";
 import { logWorkflowEvent } from "./event-logger.js";
 import * as stepHandler from "./step-handler.js";
-import { branchToken } from "./execution-token.js";
+import { branchToken, mergeTokenContext } from "./execution-token.js";
+import { WORKFLOW_ERROR_CONTEXT_KEY, buildErrorContextEntry } from "./error-routing.js";
 async function resumeBranch(em, options) {
   const branch = await em.findOne(WorkflowBranchInstance, {
     id: options.branchInstanceId,
@@ -237,9 +238,24 @@ async function advanceOneBranch(em, container, instance, definition, branch, con
       token,
       selected.fromStepId,
       selected.toStepId,
-      evalContext
+      { ...evalContext, transitionId: selected.transitionId }
     );
     if (!transitionResult.success) {
+      const routed = await followBranchErrorRoute(
+        em,
+        container,
+        instance,
+        branch,
+        token,
+        transitionResult,
+        evalContext
+      );
+      if (routed) {
+        if (branch.currentStepId === branch.joinStepId) {
+          await completeBranchAtJoin(em, instance, branch);
+        }
+        return "advanced";
+      }
       await failBranch(em, instance, branch, transitionResult.error || "Branch transition failed");
       return "failed";
     }
@@ -253,6 +269,45 @@ async function advanceOneBranch(em, container, instance, definition, branch, con
     return "failed";
   }
 }
+async function followBranchErrorRoute(em, container, instance, branch, token, transitionResult, evalContext) {
+  const { failedStepId, errorRoute } = transitionResult;
+  if (!failedStepId || !errorRoute) return false;
+  const error = transitionResult.error || "Branch transition failed";
+  await logWorkflowEvent(em, {
+    workflowInstanceId: instance.id,
+    branchInstanceId: branch.id,
+    eventType: "ERROR_ROUTED",
+    eventData: {
+      failedStepId,
+      toStepId: errorRoute.toStepId,
+      transitionId: errorRoute.transitionId,
+      branchKey: branch.branchKey,
+      error
+    },
+    tenantId: instance.tenantId,
+    organizationId: instance.organizationId
+  });
+  const errorEntry = buildErrorContextEntry(failedStepId, error);
+  mergeTokenContext(token, { [WORKFLOW_ERROR_CONTEXT_KEY]: errorEntry });
+  await em.flush();
+  const transitionHandler = await import("./transition-handler.js");
+  const routedResult = await transitionHandler.executeTransitionForToken(
+    em,
+    container,
+    token,
+    failedStepId,
+    errorRoute.toStepId,
+    {
+      ...evalContext,
+      workflowContext: {
+        ...evalContext.workflowContext,
+        [WORKFLOW_ERROR_CONTEXT_KEY]: errorEntry
+      },
+      transitionId: errorRoute.transitionId
+    }
+  );
+  return routedResult.success === true;
+}
 async function completeBranchAtJoin(em, instance, branch) {
   const now = /* @__PURE__ */ new Date();
   branch.status = "COMPLETED";