bazis 0.130.0 → 0.132.0

package/core/workflow/runtime_module/background/WorkflowRetention.ts

@@ -5,7 +5,7 @@ import { WorkflowClock } from "../../contracts/WorkflowClock";
 import { IWorkflowDefinitions } from "../../definitions_module/services/IWorkflowDefinitions.service";
 import { WORKFLOW_INSTANCES_DELETED } from "../events/Runtime.events";
 import { RuntimeDbContext } from "../model/Runtime.dbContext";
-import type { WorkflowSettings } from "../config/Runtime.config";
+import type { WorkflowSettings } from "../../contracts/Workflow.config";
 
 const DAY_MS = 86_400_000;
 

package/core/workflow/runtime_module/background/WorkflowWorker.ts

@@ -2,14 +2,14 @@ import { BackgroundService, delay } from "../../../background";
 import type { ServiceProvider } from "../../../di";
 import { WorkflowClock } from "../../contracts/WorkflowClock";
 import type { ConfigView } from "../../../kernel";
-import type { WorkflowSettings } from "../config/Runtime.config";
+import type { WorkflowSettings } from "../../contracts/Workflow.config";
 import { WorkflowJobs } from "../internal/WorkflowJobs";
 
 /** How often the scheduled starts are matched against the published versions. */
 const RECONCILE_MS = 60_000;
 
 /**
- * Takes due jobs of `bazis_wf_run_jobs` every `worker.intervalMs`, up to
+ * Takes due jobs of `bazis_wf2_run_jobs` every `worker.intervalMs`, up to
  * `worker.batchSize` at a time ({@link WorkflowJobs}). A full batch is
  * followed by the next one at once.
  */

package/core/workflow/runtime_module/events/Runtime.events.ts

@@ -1,6 +1,7 @@
 import { createEventToken } from "../../../kernel";
-import type { FormSpec } from "../../../../library/workflow";
-import type { InstanceStatus } from "../model/WfInstance.model";
+import type { FormSpec, LocalizedText } from "../../../../library/workflow";
+import type { WorkflowActor, WorkflowRequest } from "../../contracts/types";
+import type { InstanceStatus, StartedVia } from "../model/WfInstance.model";
 
 /** A token reached a user task. Published after the step commits. */
 export interface WorkflowTaskRequested {
@@ -9,7 +10,7 @@ export interface WorkflowTaskRequested {
   readonly processKey: string;
   readonly nodeId: string;
   readonly partition: string | null;
-  readonly title: string;
+  readonly title: LocalizedText;
   readonly assignee: { readonly role: string } | { readonly user: string };
   readonly form: FormSpec | null;
   /** When the task is due, from the node's `dueIn`. */
@@ -37,7 +38,33 @@ export interface WorkflowInstancesDeleted {
   readonly instanceIds: readonly string[];
 }
 
+/** What the audit events of an instance share. Published after the commit. */
+interface WorkflowInstanceAudit {
+  readonly instanceId: string;
+  readonly processKey: string;
+  readonly partition: string | null;
+  readonly actor: WorkflowActor;
+  readonly request: WorkflowRequest | null;
+}
+
+/** An instance started: by hand, from an event or on schedule. */
+export interface WorkflowInstanceStarted extends WorkflowInstanceAudit {
+  readonly version: number;
+  readonly businessKey: string | null;
+  readonly startedVia: StartedVia;
+}
+
+export interface WorkflowInstanceCancelled extends WorkflowInstanceAudit {
+  readonly reason: string | null;
+}
+
+/** The failed steps of an instance run again. */
+export type WorkflowInstanceRetried = WorkflowInstanceAudit;
+
 export const WORKFLOW_TASK_REQUESTED = createEventToken<WorkflowTaskRequested>("workflow.task-requested");
 export const WORKFLOW_TOKEN_CLOSED = createEventToken<WorkflowTokenClosed>("workflow.token-closed");
 export const WORKFLOW_INSTANCE_FINISHED = createEventToken<WorkflowInstanceFinished>("workflow.instance-finished");
 export const WORKFLOW_INSTANCES_DELETED = createEventToken<WorkflowInstancesDeleted>("workflow.instances-deleted");
+export const WORKFLOW_INSTANCE_STARTED = createEventToken<WorkflowInstanceStarted>("workflow.instance-started");
+export const WORKFLOW_INSTANCE_CANCELLED = createEventToken<WorkflowInstanceCancelled>("workflow.instance-cancelled");
+export const WORKFLOW_INSTANCE_RETRIED = createEventToken<WorkflowInstanceRetried>("workflow.instance-retried");

package/core/workflow/runtime_module/http/Events.controller.ts

@@ -15,11 +15,12 @@ export class EventsController {
     const eventKey = param(ctx, "eventKey");
     const request = await body(ctx);
     const partition = optionalString(request.partition, "partition") ?? null;
-    const { actor } = await callerOf(ctx, "workflow.events.emit", { scope: partition, event: eventKey });
+    const { actor, request: from } = await callerOf(ctx, "workflow.events.emit", { scope: partition, event: eventKey });
     const result = await this.runtime.emit(eventKey, request.payload ?? {}, {
       correlation: optionalString(request.correlation, "correlation") ?? null,
       partition,
       actor,
+      request: from,
     });
     ctx.res.status(202);
     return result;

package/core/workflow/runtime_module/http/Instances.controller.ts

@@ -1,14 +1,19 @@
 import { contextOnlyController } from "../../../http/Routing/contextOnlyControllers";
 import { can, type AccessObject } from "../../../access";
 import { Authorize, Controller, Created, Get, Post, type HttpContext } from "../../../http";
-import { body, callerOf, optionalString, pagingQuery, param, requiredString } from "../../internal/http";
+import { buildListDocument } from "../../../../library/jsonapi";
+import { body, callerOf, filterOf, listQuery, optionalString, pagingOfList, param, requiredString } from "../../internal/http";
 import type { InstanceStatus } from "../model/WfInstance.model";
+import { IWorkflowDefinitions } from "../../definitions_module/services/IWorkflowDefinitions.service";
 import { IWorkflowRuntime, type InstanceSummary } from "../services/IWorkflowRuntime.service";
 
 /** Instances over HTTP (WORKFLOW-001 §4); rights are `workflow.instances.*` (WORKFLOW-002 §6.2). */
 @Controller("workflow/instances")
 export class InstancesController {
-  constructor(private readonly runtime: IWorkflowRuntime) {}
+  constructor(
+    private readonly runtime: IWorkflowRuntime,
+    private readonly definitions: IWorkflowDefinitions,
+  ) {}
 
   @Post()
   @Authorize(can("workflow.instances.start"))
@@ -16,12 +21,14 @@ export class InstancesController {
     const request = await body(ctx);
     const processKey = requiredString(request.processKey, "processKey", 64);
     const partition = optionalString(request.partition, "partition") ?? null;
-    const { actor } = await callerOf(ctx, "workflow.instances.start", { scope: partition, process: processKey });
+    const { actor, request: from, language } = await callerOf(ctx, "workflow.instances.start", { scope: partition, process: processKey, folder: await this.definitions.folderOf(processKey) });
     const instance = await this.runtime.start(processKey, {
       input: request.input,
       partition,
       businessKey: optionalString(request.businessKey, "businessKey") ?? null,
       actor,
+      request: from,
+      language,
     });
     return Created(`${ctx.path}/${instance.id}`, instance);
   }
@@ -30,23 +37,27 @@ export class InstancesController {
   @Authorize(can("workflow.instances.read"))
   async list(ctx: HttpContext) {
     const { access } = await callerOf(ctx);
+    const list = listQuery(ctx, {
+      filter: { partition: ["eq"], processKey: ["eq"], status: ["eq"], businessKey: ["eq"], startedById: ["eq"] },
+      sort: ["createdAt", "endedAt", "status", "processKey"],
+    });
     const page = await this.runtime.instances({
-      ...pagingQuery(ctx),
+      ...pagingOfList(list),
       access: await access.filter("workflow.instances.read"),
-      partition: optionalString(ctx.query("partition"), "partition"),
-      processKey: optionalString(ctx.query("processKey"), "processKey"),
-      status: optionalString(ctx.query("status"), "status") as InstanceStatus | undefined,
-      businessKey: optionalString(ctx.query("businessKey"), "businessKey"),
-      startedById: optionalString(ctx.query("startedById"), "startedById"),
+      partition: filterOf(list, "partition"),
+      processKey: filterOf(list, "processKey"),
+      status: filterOf(list, "status") as InstanceStatus | undefined,
+      businessKey: filterOf(list, "businessKey"),
+      startedById: filterOf(list, "startedById"),
     });
-    return { data: page.items, meta: { total: page.total } };
+    return buildListDocument(page.items, list, page.total, { basePath: ctx.path });
   }
 
   @Get(":id")
   @Authorize(can("workflow.instances.read"))
   async get(ctx: HttpContext) {
     const instance = await this.runtime.instance(param(ctx, "id"));
-    await callerOf(ctx, "workflow.instances.read", objectOf(instance));
+    await callerOf(ctx, "workflow.instances.read", await this.objectOf(instance));
     return instance;
   }
 
@@ -54,7 +65,7 @@ export class InstancesController {
   @Authorize(can("workflow.instances.read"))
   async history(ctx: HttpContext) {
     const instance = await this.runtime.instance(param(ctx, "id"));
-    await callerOf(ctx, "workflow.instances.read", objectOf(instance));
+    await callerOf(ctx, "workflow.instances.read", await this.objectOf(instance));
     return { data: await this.runtime.history(instance.id) };
   }
 
@@ -63,22 +74,22 @@ export class InstancesController {
   async cancel(ctx: HttpContext) {
     const instance = await this.runtime.instance(param(ctx, "id"));
     const request = await body(ctx);
-    const { actor } = await callerOf(ctx, "workflow.instances.manage", objectOf(instance));
-    return await this.runtime.cancel(instance.id, { reason: optionalString(request.reason, "reason", 1000) ?? null, actor });
+    const { actor, request: from } = await callerOf(ctx, "workflow.instances.manage", await this.objectOf(instance));
+    return await this.runtime.cancel(instance.id, { reason: optionalString(request.reason, "reason", 1000) ?? null, actor, request: from });
   }
 
   @Post(":id/retry")
   @Authorize(can("workflow.instances.manage"))
   async retry(ctx: HttpContext) {
     const instance = await this.runtime.instance(param(ctx, "id"));
-    const { actor } = await callerOf(ctx, "workflow.instances.manage", objectOf(instance));
-    return await this.runtime.retry(instance.id, { actor });
+    const { actor, request } = await callerOf(ctx, "workflow.instances.manage", await this.objectOf(instance));
+    return await this.runtime.retry(instance.id, { actor, request });
   }
-}
-contextOnlyController(InstancesController);
 
-/** The instance as the object of a permission. */
-function objectOf(instance: InstanceSummary): AccessObject {
-  return { scope: instance.partition, process: instance.processKey, startedById: instance.startedBy.id };
+  /** The instance as the object of a permission. */
+  private async objectOf(instance: InstanceSummary): Promise<AccessObject> {
+    return { scope: instance.partition, process: instance.processKey, folder: await this.definitions.folderOf(instance.processKey), startedById: instance.startedBy.id };
+  }
 }
+contextOnlyController(InstancesController);
 

package/core/workflow/runtime_module/internal/Schedules.ts

@@ -1,4 +1,4 @@
-import { parseCron } from "../../../../library/workflow";
+import { inputSpecOf, parseCron, validateForm } from "../../../../library/workflow";
 import type { IWorkflowDefinitions, VersionDetails } from "../../definitions_module/services/IWorkflowDefinitions.service";
 import type { RuntimeDbContext } from "../model/Runtime.dbContext";
 import { WfJob } from "../model/WfJob.model";
@@ -65,7 +65,7 @@ export class Schedules {
       else await this.db.jobs.asNoTracking().where((j) => j.id.eq(job.id)).executeUpdate({ dueAt: next, lockedUntil: null, attempts: 0, lastError: null });
       for (const [nodeId, cron] of scheduleNodes(latest)) {
         if (!cron.matches(due)) continue;
-        await this.engine.begin(graph, nodeId, { input: {}, partition: null, businessKey: null, startedVia: "schedule", actor: SCHEDULE_ACTOR });
+        await this.engine.begin(graph, nodeId, { input: validateForm(inputSpecOf(latest.document), {}).value, partition: null, businessKey: null, startedVia: "schedule", actor: SCHEDULE_ACTOR });
       }
     });
   }

package/core/workflow/runtime_module/internal/ToolStep.ts

@@ -1,5 +1,6 @@
-import type { AgentToolResult } from "../../../agent";
-import { durationMs, resolveInput } from "../../../../library/workflow";
+import type { AgentSchemaContract, AgentToolResult } from "../../../agent";
+import { durationMs, maskByMapping, maskBySchema, masksPersonal, personalPaths, resolveInput, type ProcessDocument } from "../../../../library/workflow";
+import type { WorkflowToolMetadata } from "../../contracts/types";
 import type { WorkflowTools } from "../../internal/WorkflowTools";
 import type { RuntimeDbContext } from "../model/Runtime.dbContext";
 import type { WfJob } from "../model/WfJob.model";
@@ -12,6 +13,11 @@ import { dataOf, type WorkflowEngine } from "./WorkflowEngine";
  * started the instance, with the token id as its idempotency key: after a crash
  * between the call and the step the call may repeat (TOOLS-001 §7).
  */
+/** How long a claimed job belongs to its worker; if it dies, another one takes the job after that. */
+export const LEASE_MS = 5 * 60_000;
+
+const TIMEOUT_CODES: ReadonlySet<string> = new Set(["TOOL_TIMEOUT", "TOOL_TIMEOUT_OUTCOME_UNKNOWN"]);
+
 export class ToolStep {
   constructor(
     private readonly db: RuntimeDbContext,
@@ -29,21 +35,29 @@ export class ToolStep {
     const graph = await this.engine.graphOf(instance.versionId);
     const node = graph.document.nodes[token.nodeId];
     const name = String(node?.config?.tool ?? "");
-    const input = resolveInput(node?.config?.input ?? {}, dataOf(instance));
+    const input = resolveInput(node?.config?.input ?? {}, dataOf(instance, this.engine.now()));
+    const timeoutMs = stepTimeoutMs(node?.config?.timeout, graph.document);
+    // A step may run longer than the lease: another worker must not take the job and call the Tool again meanwhile.
+    if (timeoutMs !== undefined && timeoutMs >= LEASE_MS) {
+      await this.db.jobs.asNoTracking().where((j) => j.id.eq(job.id)).executeUpdate({ lockedUntil: new Date(this.engine.now().getTime() + timeoutMs + LEASE_MS) });
+    }
     const runner = this.tools.bound;
     const result: AgentToolResult = runner === undefined
       ? { callId: token.id, name, status: "error", error: { code: "TOOL_NOT_FOUND", message: `Tool ${name} is not available to processes` }, metadata: {} } as AgentToolResult
       : await runner.run(name, input, {
         idempotencyKey: token.id,
         actor: { kind: instance.startedByKind, id: instance.startedById },
-        metadata: { instanceId: instance.id, partition: instance.partition, processKey: instance.processKey, nodeId: token.nodeId },
+        metadata: { instanceId: instance.id, processKey: instance.processKey, nodeId: token.nodeId, partition: instance.partition, test: false } satisfies WorkflowToolMetadata,
         signal,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
       });
 
-    const reason = reasonOf(result);
+    const timedOut = TIMEOUT_CODES.has(result.error?.code ?? "");
+    const reason = timedOut ? "timeout" : reasonOf(result);
+    const payloads = graph.document.settings?.log?.toolPayloads === true ? this.payloads(graph.document, name, node?.config?.input, input, result) : {};
     await this.engine.inStep(instance.id, async (step) => {
       const current = step.tokens.find((t) => t.id === token.id);
-      const retryAt = current?.status === "waiting" && step.instance.status === "running" && result.status === "error" && reason === undefined
+      const retryAt = current?.status === "waiting" && step.instance.status === "running" && result.status === "error" && (reason === undefined || timedOut)
         ? nextAttempt(node?.config?.retry, job.attempts, this.engine.now())
         : undefined;
       if (retryAt !== undefined) {
@@ -58,6 +72,7 @@ export class ToolStep {
         status: result.status,
         attempt: job.attempts,
         durationMs: result.durationMs ?? null,
+        ...payloads,
         ...(result.error ? { error: { code: result.error.code ?? null, message: result.error.message, ...(reason === undefined ? {} : { reason }) } } : {}),
         ...(retryAt === undefined ? {} : { retryAt: retryAt.toISOString() }),
       });
@@ -73,6 +88,15 @@ export class ToolStep {
       }
     });
   }
+
+  /** The input and output for the history under `log.toolPayloads`; personal data is masked unless `log.maskPersonal` is `false`. */
+  private payloads(document: ProcessDocument, name: string, mapping: unknown, input: unknown, result: AgentToolResult): Record<string, unknown> {
+    if (!masksPersonal(document)) return { input, output: result.output ?? null };
+    const contract = this.tools.bound?.describe(name);
+    const schemaOf = (side: AgentSchemaContract | undefined) => (side?.kind === "json-schema" ? side.schema : undefined);
+    const masked = maskByMapping(mapping ?? {}, maskBySchema(input, schemaOf(contract?.input)), personalPaths(document));
+    return { input: masked, output: maskBySchema(result.output ?? null, schemaOf(contract?.output)) };
+  }
 }
 
 /** The business reason of a `ToolError`, if the Tool gave one. */
@@ -82,15 +106,23 @@ function reasonOf(result: AgentToolResult): string | undefined {
   return typeof reason === "string" ? reason : undefined;
 }
 
+/** How long a step's Tool may run: its `timeout`, else `settings.stepTimeout`; `undefined` leaves the Tool's own limit. */
+function stepTimeoutMs(timeout: unknown, document: ProcessDocument): number | undefined {
+  const value = typeof timeout === "string" ? timeout : document.settings?.stepTimeout;
+  return value === undefined ? undefined : durationMs(value);
+}
+
 /**
  * When to try a failed call again under the node's `retry` policy, or
- * `undefined` when the attempts are used up. The pause doubles from `backoff`
- * (10 seconds by default) and stops growing at a day.
+ * `undefined` when the attempts are used up. The pause starts at `backoff` (10
+ * seconds by default), grows by `factor` (2 by default) unless `growth` is
+ * `fixed`, and stops growing at a day.
  */
 export function nextAttempt(policy: unknown, attempts: number, now: Date): Date | undefined {
   if (typeof policy !== "object" || policy === null) return undefined;
-  const { maxAttempts, backoff } = policy as { maxAttempts?: unknown; backoff?: unknown };
+  const { maxAttempts, backoff, growth, factor } = policy as { maxAttempts?: unknown; backoff?: unknown; growth?: unknown; factor?: unknown };
   if (typeof maxAttempts !== "number" || attempts >= maxAttempts) return undefined;
   const base = typeof backoff === "string" ? durationMs(backoff) ?? 10_000 : 10_000;
-  return new Date(now.getTime() + Math.min(base * 2 ** Math.max(attempts - 1, 0), 86_400_000));
+  const scale = growth === "fixed" ? 1 : (typeof factor === "number" ? factor : 2) ** Math.max(attempts - 1, 0);
+  return new Date(now.getTime() + Math.min(base * scale, 86_400_000));
 }

package/core/workflow/runtime_module/internal/WorkflowEngine.ts

@@ -1,10 +1,10 @@
-import type { ServiceProvider } from "../../../di";
-import { EventBus, type EventToken, type Logger } from "../../../kernel";
-import { durationMs, evaluateCondition, nodeKindOf, readPath, type FormSpec, type InstanceData, type ProcessFlow, type ProcessNode } from "../../../../library/workflow";
-import type { WorkflowActor } from "../../contracts/types";
+import type { EventToken } from "../../../kernel";
+import { durationMs, evaluateExpression, initialVarsOf, isTruthy, masksPersonal, maskByMapping, nodeKindOf, outputOf, personalPaths, personalVariables, PERSONAL_MASK, readPath, type Expr, type FormSpec, type InstanceData, type ProcessFlow, type ProcessNode } from "../../../../library/workflow";
+import type { WorkflowActor, WorkflowRequest } from "../../contracts/types";
 import type { WorkflowClock } from "../../contracts/WorkflowClock";
 import type { IWorkflowDefinitions, VersionDetails } from "../../definitions_module/services/IWorkflowDefinitions.service";
-import { WORKFLOW_INSTANCE_FINISHED, WORKFLOW_TASK_REQUESTED, WORKFLOW_TOKEN_CLOSED } from "../events/Runtime.events";
+import type { WorkflowEvents } from "../../internal/WorkflowEvents";
+import { WORKFLOW_INSTANCE_CANCELLED, WORKFLOW_INSTANCE_FINISHED, WORKFLOW_INSTANCE_RETRIED, WORKFLOW_INSTANCE_STARTED, WORKFLOW_TASK_REQUESTED, WORKFLOW_TOKEN_CLOSED } from "../events/Runtime.events";
 import type { RuntimeDbContext } from "../model/Runtime.dbContext";
 import { WfHistory, type HistoryType } from "../model/WfHistory.model";
 import { WfInstance, type StartedVia } from "../model/WfInstance.model";
@@ -36,6 +36,10 @@ export interface BeginOptions {
   readonly businessKey: string | null;
   readonly startedVia: StartedVia;
   readonly actor: WorkflowActor;
+  /** Where the start came from; `null` for code, schedules and the worker. */
+  readonly request?: WorkflowRequest | null;
+  /** The event that starts it: `$event` and `$trigger.eventKey`. */
+  readonly event?: { readonly key: string; readonly payload: unknown };
 }
 
 const LIVE = new Set(["active", "waiting", "failed"]);
@@ -51,11 +55,8 @@ export class WorkflowEngine {
     private readonly db: RuntimeDbContext,
     private readonly definitions: IWorkflowDefinitions,
     private readonly graphs: GraphCache,
-    private readonly events: EventBus,
-    /** The scope of the engine: event handlers run in it. */
-    private readonly scope: ServiceProvider,
+    private readonly events: WorkflowEvents,
     private readonly clock: WorkflowClock,
-    private readonly logger?: Logger,
   ) {}
 
   /** The engine's time ({@link WorkflowClock}). */
@@ -87,6 +88,14 @@ export class WorkflowEngine {
       version: graph.version,
       partition: options.partition,
       input: options.input,
+      vars: initialVarsOf(graph.document),
+      event: options.event?.payload ?? null,
+      trigger: {
+        via: options.startedVia,
+        at: this.now().toISOString(),
+        actor: options.actor,
+        ...(options.event === undefined ? {} : { eventKey: options.event.key }),
+      },
       businessKey: options.businessKey,
       startedVia: options.startedVia,
       startedByKind: options.actor.kind,
@@ -97,6 +106,10 @@ export class WorkflowEngine {
       await this.db.saveChanges();
       const step: Step = { instance, tokens: [], graph, events: [] };
       this.history(step, null, null, "started", { via: options.startedVia }, options.actor);
+      step.events.push({
+        event: WORKFLOW_INSTANCE_STARTED as EventToken<unknown>,
+        payload: { instanceId: instance.id, processKey: graph.processKey, version: graph.version, partition: options.partition, businessKey: options.businessKey, startedVia: options.startedVia, actor: options.actor, request: options.request ?? null },
+      });
       await this.advance(step, [this.spawn(step, startNodeId, null)]);
       await this.db.saveChanges();
       this.publishAfter(transaction, step);
@@ -147,13 +160,20 @@ export class WorkflowEngine {
   /**
    * A step's Tool failed for good. An error boundary attached to the step takes
    * the token (first one whose `errorCode` equals the Tool's `reason` or error
-   * code, else one without `errorCode`); otherwise the instance fails.
+   * code, else one without `errorCode`); otherwise `onError: "skip"` moves on with
+   * `{ skipped: true, error }`; otherwise the instance fails.
    */
   async failStep(step: Step, token: WfToken, error: { readonly code: string; readonly message: string; readonly reason?: string }): Promise<void> {
     const boundaries = (step.graph.boundaries.get(token.nodeId) ?? []).filter(([, node]) => node.kind === "boundaryError");
     const matching = boundaries.find(([, node]) => node.config?.errorCode !== undefined && (node.config.errorCode === error.reason || node.config.errorCode === error.code))
       ?? boundaries.find(([, node]) => node.config?.errorCode === undefined);
     if (!matching) {
+      if (step.graph.document.nodes[token.nodeId]?.config?.onError === "skip") {
+        const skipped = { code: error.code, message: error.message, ...(error.reason === undefined ? {} : { reason: error.reason }) };
+        this.history(step, token, token.nodeId, "skipped", skipped);
+        await this.complete(step, token.id, { skipped: true, error: skipped });
+        return;
+      }
       this.fail(step, token, error.code, error.message);
       return;
     }
@@ -194,6 +214,7 @@ export class WorkflowEngine {
     const token = step.tokens.find((t) => t.id === tokenId);
     if (!token || token.status !== "waiting" || step.instance.status !== "running") return false;
     const node = step.graph.document.nodes[token.nodeId];
+    if (node?.kind === "eventWait" || node?.kind === "boundaryEvent") step.instance.event = payload;
     if (node?.kind === "eventWait") {
       this.history(step, token, token.nodeId, "event", { event: eventKey });
       return await this.complete(step, tokenId, payload);
@@ -231,8 +252,12 @@ export class WorkflowEngine {
   }
 
   /** Retries the failed steps: their tokens are back on their nodes and the instance runs again. */
-  async retry(step: Step, actor: WorkflowActor): Promise<void> {
+  async retry(step: Step, actor: WorkflowActor, request: WorkflowRequest | null = null): Promise<void> {
     const failed = step.tokens.filter((t) => t.status === "failed");
+    step.events.push({
+      event: WORKFLOW_INSTANCE_RETRIED as EventToken<unknown>,
+      payload: { instanceId: step.instance.id, processKey: step.instance.processKey, partition: step.instance.partition, actor, request },
+    });
     step.instance.status = "running";
     step.instance.error = null;
     for (const token of failed) {
@@ -243,8 +268,12 @@ export class WorkflowEngine {
   }
 
   /** Closes every live token, job and subscription; the application drops the tasks on `WORKFLOW_TOKEN_CLOSED`. */
-  async cancel(step: Step, reason: string | null, actor: WorkflowActor): Promise<void> {
+  async cancel(step: Step, reason: string | null, actor: WorkflowActor, request: WorkflowRequest | null = null): Promise<void> {
     const open = step.tokens.filter((t) => LIVE.has(t.status));
+    step.events.push({
+      event: WORKFLOW_INSTANCE_CANCELLED as EventToken<unknown>,
+      payload: { instanceId: step.instance.id, processKey: step.instance.processKey, partition: step.instance.partition, reason, actor, request },
+    });
     for (const token of open) {
       token.status = "cancelled";
       token.endedAt = this.now();
@@ -287,6 +316,7 @@ export class WorkflowEngine {
     if (step.instance.status === "running" && !step.tokens.some((t) => LIVE.has(t.status))) {
       step.instance.status = "completed";
       step.instance.endedAt = this.now();
+      step.instance.output = outputOf(step.graph.document, step.instance.vars);
       this.history(step, null, null, "completed", null);
       this.finished(step, "completed");
     }
@@ -308,6 +338,8 @@ export class WorkflowEngine {
     // An error boundary that caught a step's failure: it only leads on.
     if (role === "boundary") return this.leave(step, token, this.single(step, token.nodeId));
     switch (node.kind) {
+      case "assign":
+        return this.assign(step, token, node);
       case "serviceTask":
         return this.arm(step, token, this.waitForTool(step, token));
       case "userTask":
@@ -326,8 +358,28 @@ export class WorkflowEngine {
     }
   }
 
+  /**
+   * An `assign` step: each value sees the ones before it. The history names the
+   * variables; their values go there only under `log.variables`, personal ones masked.
+   */
+  private assign(step: Step, token: WfToken, node: ProcessNode): WfToken[] {
+    const { document } = step.graph;
+    const assignments = (node.config?.assignments ?? []) as readonly { readonly var: string; readonly value: Expr }[];
+    const personal = masksPersonal(document) ? personalVariables(document) : new Set<string>();
+    const reads = masksPersonal(document) ? personalPaths(document) : new Set<string>();
+    const logged: Record<string, unknown> = {};
+    for (const { var: name, value } of assignments) {
+      const result = evaluateExpression(value, dataOf(step.instance, this.now())) ?? null;
+      step.instance.vars = { ...step.instance.vars, [name]: result };
+      logged[name] = personal.has(name) ? PERSONAL_MASK : maskByMapping(value, result, reads);
+    }
+    const log = document.settings?.log?.variables === true;
+    this.history(step, token, token.nodeId, "assigned", log ? { values: logged } : { vars: assignments.map((item) => item.var) });
+    return this.leave(step, token, this.single(step, token.nodeId));
+  }
+
   private waitForTimer(step: Step, token: WfToken, node: ProcessNode): WfToken[] {
-    const dueAt = timerDue(node.config ?? {}, dataOf(step.instance), this.now());
+    const dueAt = timerDue(node.config ?? {}, dataOf(step.instance, this.now()), this.now());
     if (dueAt === undefined) {
       this.fail(step, token, "bad_timer", `the timer of ${token.nodeId} has no valid date`);
       return [];
@@ -345,7 +397,7 @@ export class WorkflowEngine {
     if (host.status !== "waiting") return next;
     for (const [id, node] of step.graph.boundaries.get(host.nodeId) ?? []) {
       if (node.kind === "boundaryEvent") {
-        const correlation = correlationOf(node.config ?? {}, dataOf(step.instance));
+        const correlation = correlationOf(node.config ?? {}, dataOf(step.instance, this.now()));
         if (correlation === undefined) {
           this.fail(step, host, "bad_correlation", `the correlation of ${id} has no value`);
           return [];
@@ -356,7 +408,7 @@ export class WorkflowEngine {
         continue;
       }
       if (node.kind !== "boundaryTimer") continue;
-      const dueAt = timerDue(node.config ?? {}, dataOf(step.instance), this.now());
+      const dueAt = timerDue(node.config ?? {}, dataOf(step.instance, this.now()), this.now());
       if (dueAt === undefined) {
         this.fail(step, host, "bad_timer", `the timer of ${id} has no valid date`);
         return [];
@@ -378,7 +430,7 @@ export class WorkflowEngine {
   }
 
   private waitForEvent(step: Step, token: WfToken, node: ProcessNode): WfToken[] {
-    const correlation = correlationOf(node.config ?? {}, dataOf(step.instance));
+    const correlation = correlationOf(node.config ?? {}, dataOf(step.instance, this.now()));
     if (correlation === undefined) {
       this.fail(step, token, "bad_correlation", `the correlation of ${token.nodeId} has no value`);
       return [];
@@ -430,8 +482,8 @@ export class WorkflowEngine {
   private choose(step: Step, token: WfToken): WfToken[] {
     const flows = step.graph.outgoing.get(token.nodeId) ?? [];
     if (flows.length === 1) return this.leave(step, token, flows[0]!);
-    const data = dataOf(step.instance);
-    const chosen = flows.find(([, flow]) => flow.condition !== undefined && evaluateCondition(flow.condition, data))
+    const data = dataOf(step.instance, this.now());
+    const chosen = flows.find(([, flow]) => flow.condition !== undefined && isTruthy(evaluateExpression(flow.condition, data)))
       ?? flows.find(([, flow]) => flow.isDefault === true);
     if (!chosen) {
       this.fail(step, token, "no_branch", "no condition matched and there is no default flow");
@@ -493,21 +545,12 @@ export class WorkflowEngine {
     });
   }
 
-  /**
-   * Events go out after the commit, so a handler never sees a step that rolled
-   * back. A failing handler is logged: the step is already saved.
-   */
+  /** Events go out after the commit, so a handler never sees a step that rolled back. */
   private publishAfter(transaction: { afterCommit(callback: () => void | Promise<void>): void }, step: Step): void {
     if (step.events.length === 0) return;
     const events = [...step.events];
     transaction.afterCommit(async () => {
-      for (const { event, payload } of events) {
-        try {
-          await this.events.publishScoped(this.scope, event, payload);
-        } catch (error) {
-          this.logger?.error("workflow event handler failed", { event: event.name, instance: step.instance.id, error: error instanceof Error ? error.message : String(error) });
-        }
-      }
+      for (const { event, payload } of events) await this.events.publish(event, payload);
     });
   }
 }
@@ -537,6 +580,15 @@ export function correlationOf(config: Readonly<Record<string, unknown>>, data: I
   return value === undefined || value === null || value === "" || typeof value === "object" ? undefined : String(value);
 }
 
-export function dataOf(instance: WfInstance): InstanceData {
-  return { input: instance.input, vars: instance.vars, nodes: instance.nodes };
+/** What expressions read in an instance at this moment of the engine's clock. */
+export function dataOf(instance: WfInstance, now: Date): InstanceData {
+  return {
+    input: instance.input,
+    vars: instance.vars,
+    nodes: instance.nodes,
+    event: instance.event,
+    trigger: instance.trigger,
+    run: { id: instance.id, processKey: instance.processKey, version: instance.version, partition: instance.partition, test: instance.test },
+    now: now.toISOString(),
+  };
 }

package/core/workflow/runtime_module/internal/WorkflowJobs.ts

@@ -4,11 +4,9 @@ import { RuntimeDbContext } from "../model/Runtime.dbContext";
 import type { WfJob } from "../model/WfJob.model";
 import { Schedules } from "./Schedules";
 import { TimerStep } from "./TimerStep";
-import { ToolStep } from "./ToolStep";
+import { LEASE_MS, ToolStep } from "./ToolStep";
 import { WorkflowEngine } from "./WorkflowEngine";
 
-/** How long a claimed job belongs to its worker; if it dies, another one takes the job after that. */
-const LEASE_MS = 5 * 60_000;
 /** A job that keeps failing outside its Tool (the database, a lost version) fails its step after this many tries. */
 const MAX_JOB_ATTEMPTS = 5;
 
@@ -16,7 +14,7 @@ const MAX_JOB_ATTEMPTS = 5;
 export type JobFailureReport = (message: string, error: unknown, fields?: Readonly<Record<string, unknown>>) => void;
 
 /**
- * Claiming and running jobs of `bazis_wf_run_jobs`: the work of the worker, and
+ * Claiming and running jobs of `bazis_wf2_run_jobs`: the work of the worker, and
  * of `drain` in tests. Every job runs in its own DI scope.
  */
 export class WorkflowJobs {

package/core/workflow/runtime_module/model/Runtime.dbContext.ts

@@ -19,7 +19,7 @@ export const RUNTIME_ENTITIES = [WfInstance, WfToken, WfJob, WfSubscription, WfH
 /** The tables of the Runtime part: bazis creates and checks them in the application database. */
 export const runtimeStore = defineOrmOwnedStoreV1({
   contract: "bazis.orm-owned-store/v1",
-  storeKey: "bazis.workflow.runtime",
+  storeKey: "bazis.workflow.runtime.v2",
   formatVersion: 1,
-  ownedScope: { schema: "public", tablePrefix: "bazis_wf_run_" },
+  ownedScope: { schema: "public", tablePrefix: "bazis_wf2_run_" },
 });

package/core/workflow/runtime_module/model/WfHistory.model.ts

@@ -1,12 +1,12 @@
 import { Column, Entity, ForeignKey, Index, UUID } from "../../../orm";
 import { WfInstance } from "./WfInstance.model";
 
-export type HistoryType = "started" | "entered" | "left" | "tool" | "timer" | "event" | "error" | "retried" | "cancelled" | "completed";
+export type HistoryType = "started" | "entered" | "left" | "tool" | "assigned" | "skipped" | "timer" | "event" | "error" | "retried" | "cancelled" | "completed";
 
 /** The journal of an instance, append only. Its v7 ids give the order. */
 @ForeignKey(() => WfInstance, { properties: ["instanceId"], onDelete: "cascade" })
 @Index(["instanceId", "id"])
-@Entity({ table: "bazis_wf_run_history" })
+@Entity({ table: "bazis_wf2_run_history" })
 export class WfHistory {
   @UUID({ version: "v7" })
   id = "";