@nanobpm/nano-workforce 0.106.1 → 0.106.3

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.106.3](https://github.com/nanobpm/nano-workforce/compare/v0.106.2...v0.106.3) (2026-08-20)
+
+
+### Bug Fixes
+
+* **models:** regenerate stale retro.bpmn DI ([#365](https://github.com/nanobpm/nano-workforce/issues/365)) ([5619ee5](https://github.com/nanobpm/nano-workforce/commit/5619ee5805fb788ae5deebeb75bb0aa11f9c478d)), closes [355/#356](https://github.com/nanobpm/nano-workforce/issues/356)
+
+## [0.106.2](https://github.com/nanobpm/nano-workforce/compare/v0.106.1...v0.106.2) (2026-08-20)
+
+
+### Bug Fixes
+
+* **velocity:** bucket burn-up by local timezone, not UTC ([#361](https://github.com/nanobpm/nano-workforce/issues/361)) ([#362](https://github.com/nanobpm/nano-workforce/issues/362)) ([84d842a](https://github.com/nanobpm/nano-workforce/commit/84d842ad443fba8a0c399bdd5f4fca466da4a21c))
+
 ## [0.106.1](https://github.com/nanobpm/nano-workforce/compare/v0.106.0...v0.106.1) (2026-08-20)
 
 

package/app/mergesPerDay.test.ts

@@ -12,6 +12,13 @@ import { assert, assertEquals } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
 import { deriveMergesPerDay, type MergeAuditRow, pollMergesPerDay } from "./mergesPerDay.ts";
 
+// The bucketing is now LOCAL-calendar-day (issue #361: use the viewer's timezone, not UTC). The
+// derivation buckets in an explicit IANA `timeZone` argument (via `Intl.DateTimeFormat`), so these
+// tests pass the zone directly rather than mutating the process-global `process.env.TZ` — which
+// `node --test` runs concurrently across files, so an in-process `TZ` flip could leak into and
+// reorder unrelated date-handling tests. The UTC-based assertions pass `"UTC"`; the
+// timezone-specific ones pass the zone they exercise.
+
 // A tiny in-memory record gateway (all/find/insert/update/delete), mirroring the fake-app style used
 // across the app tests (see app/delivery.test.ts), enough to exercise the `pollMergesPerDay`
 // projection.
@@ -62,7 +69,7 @@ test("counts DISTINCT merged PRs per calendar day", () => {
     merged("o/r#1", "2026-01-01T09:00:00Z"),
     merged("o/r#2", "2026-01-01T18:30:00Z"),
     merged("o/r#3", "2026-01-02T10:00:00Z"),
-  ]);
+  ], "UTC");
   assertEquals(days.map((d) => [d.day, d.merged]), [
     ["2026-01-01", 2],
     ["2026-01-02", 1],
@@ -74,7 +81,7 @@ test("dedupes duplicate merged rows for the same PR on the same day (COUNT DISTI
     merged("o/r#1", "2026-01-01T09:00:00Z"),
     merged("o/r#1", "2026-01-01T09:00:05Z"), // retry / already-merged short-circuit
     merged("o/r#1", "2026-01-01T23:59:00Z"),
-  ]);
+  ], "UTC");
   assertEquals(days.length, 1);
   assertEquals(days[0].merged, 1);
 });
@@ -84,7 +91,7 @@ test("the same PR merged on two different days counts once per day", () => {
   const days = deriveMergesPerDay([
     merged("o/r#1", "2026-01-01T09:00:00Z"),
     merged("o/r#1", "2026-01-02T09:00:00Z"),
-  ]);
+  ], "UTC");
   assertEquals(days.map((d) => [d.day, d.merged]), [
     ["2026-01-01", 1],
     ["2026-01-02", 1],
@@ -96,7 +103,7 @@ test("ignores queued and blocked attempts", () => {
     merged("o/r#1", "2026-01-01T09:00:00Z"),
     { pr_key: "o/r#2", outcome: "queued", at: "2026-01-01T09:10:00Z" },
     { pr_key: "o/r#3", outcome: "blocked", at: "2026-01-01T09:20:00Z" },
-  ]);
+  ], "UTC");
   assertEquals(days.length, 1);
   assertEquals(days[0].merged, 1);
 });
@@ -107,7 +114,7 @@ test("orders days ascending and carries a running burn-up cumulative", () => {
     merged("o/r#1", "2026-01-01T10:00:00Z"),
     merged("o/r#2", "2026-01-01T11:00:00Z"),
     merged("o/r#4", "2026-01-02T10:00:00Z"),
-  ]);
+  ], "UTC");
   assertEquals(days.map((d) => d.day), ["2026-01-01", "2026-01-02", "2026-01-03"]);
   assertEquals(days.map((d) => d.merged), [2, 1, 1]);
   assertEquals(days.map((d) => d.cumulative), [2, 3, 4]);
@@ -122,7 +129,7 @@ test("bar scales against the busiest day: full for the max, non-empty for a lone
     merged("o/r#4", "2026-01-01T04:00:00Z"),
     // day B: 1 merge → short but visible bar
     merged("o/r#5", "2026-01-02T01:00:00Z"),
-  ]);
+  ], "UTC");
   const [a, b] = days;
   assert(a.bar.length > b.bar.length, "the busier day must draw a longer bar");
   assert(b.bar.length >= 1, "a day with any merge must draw at least one glyph");
@@ -133,6 +140,83 @@ test("empty audit yields no days", () => {
   assertEquals(deriveMergesPerDay([]), []);
 });
 
+test("buckets by the viewer's LOCAL calendar day, not UTC (issue #361)", () => {
+  // 02:00Z on Jan 1 is still Dec 31 in a west-of-UTC zone (America/New_York, UTC-5).
+  {
+    const days = deriveMergesPerDay([merged("o/r#1", "2026-01-01T02:00:00Z")], "America/New_York");
+    assertEquals(
+      days.map((d) => d.day),
+      ["2025-12-31"],
+    );
+  }
+  // 23:00Z on Jan 1 is already Jan 2 in an east-of-UTC zone (Pacific/Kiritimati, UTC+14).
+  {
+    const days = deriveMergesPerDay([merged("o/r#1", "2026-01-01T23:00:00Z")], "Pacific/Kiritimati");
+    assertEquals(
+      days.map((d) => d.day),
+      ["2026-01-02"],
+    );
+  }
+});
+
+test("two merges either side of local midnight land on the same local day (issue #361)", () => {
+  // In UTC these are two different UTC days; in America/New_York (UTC-5) both are Jan 1 evening,
+  // so a local-time bucketing counts them together on 2026-01-01.
+  {
+    const days = deriveMergesPerDay(
+      [
+        merged("o/r#1", "2026-01-01T18:00:00Z"), // 13:00 local, Jan 1
+        merged("o/r#2", "2026-01-02T04:00:00Z"), // 23:00 local, Jan 1
+      ],
+      "America/New_York",
+    );
+    assertEquals(
+      days.map((d) => [d.day, d.merged]),
+      [["2026-01-01", 2]],
+    );
+  }
+});
+
+test("non-ISO / malformed `at` still groups deterministically without throwing", () => {
+  const days = deriveMergesPerDay([
+    { pr_key: "o/r#1", outcome: "merged", at: "not-a-timestamp" },
+    { pr_key: "o/r#2", outcome: "merged", at: "not-a-timestamp" },
+  ], "UTC");
+  assertEquals(days.length, 1);
+  assertEquals(days[0].day, "not-a-timestamp");
+  assertEquals(days[0].merged, 2);
+});
+
+test("ambiguous partially-formed `at` (date-only / offset-less) buckets on the trimmed string, not a runtime-dependent day", () => {
+  // `new Date("2026-01-01")` parses as UTC midnight while `new Date("2026-01-01T12:00:00")` parses in
+  // the host's local zone — bucketing either would be runtime/timezone-dependent, the exact drift this
+  // read model exists to avoid. Neither carries an explicit `Z`/offset, so both must fall back to the
+  // trimmed string and group deterministically regardless of the viewer's `timeZone`.
+  const rows: MergeAuditRow[] = [
+    { pr_key: "o/r#1", outcome: "merged", at: "2026-01-01" },
+    { pr_key: "o/r#2", outcome: "merged", at: "2026-01-01T12:00:00" },
+  ];
+  for (const zone of ["UTC", "America/New_York", "Pacific/Kiritimati"]) {
+    const days = deriveMergesPerDay(rows, zone);
+    assertEquals(days.map((d) => [d.day, d.merged]), [
+      ["2026-01-01", 1],
+      ["2026-01-01T12:00:00", 1],
+    ]);
+  }
+});
+
+test("an invalid IANA timeZone falls back to the host zone instead of throwing (issue #361)", () => {
+  // A bogus zone would make `Intl.DateTimeFormat` throw a `RangeError`; bucketing must stay
+  // deterministic and not wedge `deriveMergesPerDay`/`pollMergesPerDay`.
+  const days = deriveMergesPerDay(
+    [merged("o/r#1", "2026-01-01T12:00:00Z")],
+    "Not/AZone",
+  );
+  assertEquals(days.length, 1);
+  assertEquals(days[0].merged, 1);
+  assert(/^\d{4}-\d{2}-\d{2}$/.test(days[0].day));
+});
+
 test("pollMergesPerDay projects the aggregate onto merges_per_day", async () => {
   const { data, stores } = memData();
   stores.merges = [
@@ -141,7 +225,7 @@ test("pollMergesPerDay projects the aggregate onto merges_per_day", async () =>
     { id: 3, pr_key: "o/r#2", outcome: "merged", at: "2026-01-02T09:00:00Z" },
     { id: 4, pr_key: "o/r#3", outcome: "queued", at: "2026-01-02T09:10:00Z" }, // ignored
   ];
-  await pollMergesPerDay(data);
+  await pollMergesPerDay(data, "UTC");
   const rows = (stores.merges_per_day ?? []).slice().sort((x, y) => x.day.localeCompare(y.day));
   assertEquals(rows.map((r) => [r.day, r.merged, r.cumulative]), [
     ["2026-01-01", 1, 1],
@@ -153,10 +237,10 @@ test("pollMergesPerDay projects the aggregate onto merges_per_day", async () =>
 test("pollMergesPerDay is idempotent — a steady-state re-run writes nothing", async () => {
   const { data, stores, writes } = memData();
   stores.merges = [{ id: 1, pr_key: "o/r#1", outcome: "merged", at: "2026-01-01T09:00:00Z" }];
-  await pollMergesPerDay(data);
+  await pollMergesPerDay(data, "UTC");
   const afterFirst = writes();
   assert(afterFirst > 0, "the first pass must project at least one row");
-  await pollMergesPerDay(data);
+  await pollMergesPerDay(data, "UTC");
   assertEquals(writes(), afterFirst, "a steady-state re-run must not write");
 });
 
@@ -166,7 +250,7 @@ test("pollMergesPerDay prunes a day that no longer derives from the audit", asyn
     { day: "2025-12-31", merged: 3, cumulative: 3, bar: "███", updated_at: "old" },
   ];
   stores.merges = [{ id: 1, pr_key: "o/r#1", outcome: "merged", at: "2026-01-01T09:00:00Z" }];
-  await pollMergesPerDay(data);
+  await pollMergesPerDay(data, "UTC");
   const days = (stores.merges_per_day ?? []).map((r: any) => r.day);
   assert(!days.includes("2025-12-31"), "a stale day must be pruned");
   assert(days.includes("2026-01-01"), "the derived day must be present");

package/app/mergesPerDay.ts

@@ -7,10 +7,12 @@
 // set is not exhaustive), `at` = ISO timestamp. Only `outcome = 'merged'` rows feed this aggregate,
 // so merged-per-day is
 // fully DERIVABLE from that audit trail with NO new write-path bookkeeping (AGENTS.md: "Derivation
-// over duplication"). The canonical aggregate is the one in the issue:
+// over duplication"). The `at` audit value is UTC, but the day is bucketed in the viewer's LOCAL
+// timezone (issue #361) so an operator sees merges on the calendar day they happened locally, not
+// shifted across a UTC midnight. The canonical aggregate is the one in the issue, in local time:
 //
-//   SELECT date(at) AS day, COUNT(DISTINCT pr_key) AS merged
-//   FROM merges WHERE outcome = 'merged' GROUP BY date(at);
+//   SELECT date(at, 'localtime') AS day, COUNT(DISTINCT pr_key) AS merged
+//   FROM merges WHERE outcome = 'merged' GROUP BY date(at, 'localtime');
 //
 // Two halves, mirroring the `deriveDelivery`/`pollDelivery` and `deriveLineage`/`pollLineage`
 // convention:
@@ -37,7 +39,7 @@ export interface MergeAuditRow {
 
 /** One projected calendar day of merge throughput. */
 export interface MergeDay {
-  /** Calendar day, ISO `YYYY-MM-DD` (SQLite `date(at)`). */
+  /** Local calendar day, ISO `YYYY-MM-DD` (SQLite `date(at, 'localtime')` — issue #361). */
   day: string;
   /** Distinct PRs merged that day (`COUNT(DISTINCT pr_key)`). */
   merged: number;
@@ -51,12 +53,72 @@ export interface MergeDay {
 const BAR_WIDTH = 30;
 const BAR_FULL = "█";
 
-/** The calendar day of an ISO timestamp — the JS twin of SQLite `date(at)`. A well-formed `merges.at`
- *  is an ISO string, so the first 10 chars are `YYYY-MM-DD`; fall back to the whole trimmed value for
- *  any non-ISO shape so a malformed row still groups deterministically rather than throwing. */
-function dayOf(at: string): string {
+/** The **local** calendar day of an ISO timestamp — the viewer's-timezone twin of SQLite
+ *  `date(at, 'localtime')` (issue #361). The `merges.at` audit value is a UTC ISO string, but the
+ *  Velocity page is read by an operator in their own timezone, so bucketing on the UTC date split a
+ *  single local day across two rows (a late-evening merge west of UTC, or an early-morning one east
+ *  of it, landed on the wrong day). We derive the day in the target `timeZone` via
+ *  `Intl.DateTimeFormat` — an explicit, side-effect-free zone rather than one mutated through the
+ *  process-global `process.env.TZ`. When `timeZone` is omitted the formatter uses the host's
+ *  resolved zone (so a remote deployment can still pin the operator's zone via `TZ`, and a
+ *  co-located console — the default `npm start` on `localhost` — is already the browser's zone). An
+ *  invalid/unknown IANA `timeZone` falls back to the host-resolved zone (rather than throwing a
+ *  `RangeError` that would wedge `deriveMergesPerDay`/`pollMergesPerDay`), so bucketing stays
+ *  deterministic. Any value that is not an UNAMBIGUOUS ISO instant — one carrying an explicit
+ *  timezone designator (`Z` or a `±HH:MM`/`±HHMM` offset) — falls back to the whole trimmed string so
+ *  it still groups deterministically. This deliberately excludes partially-formed values a bare
+ *  `new Date(s)` would still parse but *ambiguously*: a date-only `"2026-01-01"` is read as UTC
+ *  midnight while an offset-less `"2026-01-01T12:00:00"` is read in the host's local zone — so
+ *  bucketing them would be runtime/timezone-dependent, the very drift this read model exists to avoid.
+ *  Production `merges.at` values are always `new Date().toISOString()` (UTC, `Z`-suffixed), so only a
+ *  malformed audit row ever takes the fallback. */
+const dayFormatters = new Map<string, Intl.DateTimeFormat>();
+
+/** An unambiguous ISO-8601 instant: a full `YYYY-MM-DDTHH:MM[:SS[.sss]]` carrying an explicit zone
+ *  designator (`Z`, or a `±HH:MM`/`±HHMM` offset). Only these parse to a timezone-independent instant;
+ *  anything else (date-only, offset-less datetime, free text) buckets ambiguously, so `dayOf` treats
+ *  it as a non-instant and groups on the trimmed string instead. */
+const ISO_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
+
+/** A cached `en-CA` day formatter for `timeZone`, falling back to the host-resolved zone when the
+ *  zone is invalid/unknown (an invalid IANA string makes `Intl.DateTimeFormat` throw a `RangeError`).
+ *  Keyed so an invalid zone is only probed once. */
+function dayFormatter(timeZone?: string): Intl.DateTimeFormat {
+  const key = timeZone ?? "";
+  const cached = dayFormatters.get(key);
+  if (cached) return cached;
+  const opts: Intl.DateTimeFormatOptions = {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  };
+  let fmt: Intl.DateTimeFormat;
+  try {
+    fmt = new Intl.DateTimeFormat("en-CA", { ...opts, timeZone });
+  } catch {
+    fmt = new Intl.DateTimeFormat("en-CA", opts);
+  }
+  dayFormatters.set(key, fmt);
+  return fmt;
+}
+
+function dayOf(at: string, timeZone?: string): string {
   const s = String(at).trim();
-  return /^\d{4}-\d{2}-\d{2}/.test(s) ? s.slice(0, 10) : s;
+  // Only bucket unambiguous ISO instants (explicit `Z`/offset). A partially-formed value a bare
+  // `new Date(s)` would still parse — a date-only or offset-less datetime — buckets differently per
+  // runtime/timezone, so group it deterministically on the trimmed string instead.
+  if (!ISO_INSTANT.test(s)) return s;
+  const d = new Date(s);
+  if (Number.isNaN(d.getTime())) return s;
+  const parts = dayFormatter(timeZone).formatToParts(d);
+  const field = (type: string) => parts.find((p) => p.type === type)?.value ?? "";
+  const year = field("year");
+  const month = field("month");
+  const day = field("day");
+  // Guard against a formatter that somehow omits a field — never emit a `"--"`-shaped key; fall back
+  // to the trimmed string so the row still groups deterministically.
+  if (!year || !month || !day) return s;
+  return `${year}-${month}-${day}`;
 }
 
 /** Render a proportional bar: `merged` glyphs scaled against the busiest day's `max`, min one glyph
@@ -69,17 +131,20 @@ function barFor(merged: number, max: number): string {
 
 /** PURE aggregate: merge audit rows → one ordered `MergeDay` per calendar day (ascending).
  *
- * Only `outcome === "merged"` rows count; `queued`/`blocked` attempts are ignored. Within a day a
- * `pr_key` is counted once (`COUNT(DISTINCT pr_key)`), so duplicate `merged` audit rows — an
- * `already-merged` short-circuit or a retry — do not double-count. `cumulative` is the running total
- * across days (burn-up); `bar` is scaled against the busiest day so the chart is comparable. */
-export function deriveMergesPerDay(rows: readonly MergeAuditRow[]): MergeDay[] {
+ * Days are bucketed in `timeZone` (an IANA zone, e.g. `America/New_York`); omit it to use the host's
+ * resolved zone — the production default, matching SQLite `date(at, 'localtime')` for the operator's
+ * console (issue #361). Only `outcome === "merged"` rows count; `queued`/`blocked` attempts are
+ * ignored. Within a day a `pr_key` is counted once (`COUNT(DISTINCT pr_key)`), so duplicate `merged`
+ * audit rows — an `already-merged` short-circuit or a retry — do not double-count. `cumulative` is
+ * the running total across days (burn-up); `bar` is scaled against the busiest day so the chart is
+ * comparable. */
+export function deriveMergesPerDay(rows: readonly MergeAuditRow[], timeZone?: string): MergeDay[] {
   // day -> set of distinct merged pr_keys that day.
   const prKeysByDay = new Map<string, Set<string>>();
   for (const r of rows) {
     if (r.outcome !== "merged") continue;
     if (r.pr_key == null || r.at == null) continue;
-    const day = dayOf(r.at);
+    const day = dayOf(r.at, timeZone);
     let set = prKeysByDay.get(day);
     if (!set) {
       set = new Set<string>();
@@ -114,13 +179,14 @@ const mergesAudit = (data: DataLayer) => data.table<MergeAuditRow>("merges", "id
  * it onto the `merges_per_day` read table the Velocity page reads. Additive/derived only — never
  * touches `merges`. Upserts a day only when its projection actually changes (so a steady-state pass is
  * a no-op) and prunes any stale day row that no longer derives (defensive — days are append-only in
- * practice, but a purge/rewrite of the audit must not leave a phantom). */
-export async function pollMergesPerDay(data: DataLayer): Promise<void> {
+ * practice, but a purge/rewrite of the audit must not leave a phantom). Buckets in `timeZone` (an
+ * IANA zone) when given; the production caller omits it to use the host's resolved zone. */
+export async function pollMergesPerDay(data: DataLayer, timeZone?: string): Promise<void> {
   try {
     // Only `outcome === "merged"` rows contribute to the aggregate, so filter at the read rather than
     // scanning queued/blocked rows as the audit grows (deriveMergesPerDay ignores non-merged rows too).
     const audit = await mergesAudit(data).find({ outcome: "merged" });
-    const want = deriveMergesPerDay(audit);
+    const want = deriveMergesPerDay(audit, timeZone);
     const wantByDay = new Map(want.map((d) => [d.day, d]));
 
     const existing = await mergesPerDay(data).all();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.106.1",
+  "version": "0.106.3",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",

package/resources/processes/retro.bpmn

@@ -146,27 +146,27 @@
         <dc:Bounds x="616" y="80" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_gw-deviations" bpmnElement="gw-deviations" isMarkerVisible="true">
-        <dc:Bounds x="776" y="95" width="50" height="50" />
+        <dc:Bounds x="816" y="95" width="50" height="50" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="770" y="65" width="62" height="14" />
+          <dc:Bounds x="801" y="76" width="81" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_conformance-escalation" bpmnElement="conformance-escalation">
-        <dc:Bounds x="751" y="240" width="100" height="80" />
+        <dc:Bounds x="966" y="240" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_record-conformance-ack" bpmnElement="record-conformance-ack">
-        <dc:Bounds x="911" y="240" width="100" height="80" />
+        <dc:Bounds x="1166" y="240" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_synthesize" bpmnElement="synthesize">
-        <dc:Bounds x="1056" y="80" width="100" height="80" />
+        <dc:Bounds x="1366" y="80" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_record" bpmnElement="record">
-        <dc:Bounds x="1256" y="80" width="100" height="80" />
+        <dc:Bounds x="1566" y="80" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_End" bpmnElement="End">
-        <dc:Bounds x="1456" y="102" width="36" height="36" />
+        <dc:Bounds x="1766" y="102" width="36" height="36" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1434" y="143" width="80" height="14" />
+          <dc:Bounds x="1744" y="143" width="80" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNEdge id="BPMNEdge_f_start" bpmnElement="f_start">
@@ -183,32 +183,36 @@
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_toDeviationsGw" bpmnElement="f_toDeviationsGw">
         <di:waypoint x="716" y="120" />
-        <di:waypoint x="776" y="120" />
+        <di:waypoint x="816" y="120" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_noDeviations" bpmnElement="f_noDeviations">
-        <di:waypoint x="826" y="120" />
-        <di:waypoint x="1056" y="120" />
+        <di:waypoint x="866" y="120" />
+        <di:waypoint x="1366" y="120" />
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_f_toRecord" bpmnElement="f_toRecord">
+        <di:waypoint x="1466" y="120" />
+        <di:waypoint x="1566" y="120" />
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_f_toEnd" bpmnElement="f_toEnd">
+        <di:waypoint x="1666" y="120" />
+        <di:waypoint x="1766" y="120" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_deviations" bpmnElement="f_deviations">
-        <di:waypoint x="801" y="145" />
-        <di:waypoint x="801" y="240" />
+        <di:waypoint x="841" y="145" />
+        <di:waypoint x="841" y="280" />
+        <di:waypoint x="966" y="280" />
+        <bpmndi:BPMNLabel>
+          <dc:Bounds x="846" y="206" width="74" height="14" />
+        </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_toConformanceAck" bpmnElement="f_toConformanceAck">
-        <di:waypoint x="851" y="280" />
-        <di:waypoint x="911" y="280" />
+        <di:waypoint x="1066" y="280" />
+        <di:waypoint x="1166" y="280" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_ackToSynthesize" bpmnElement="f_ackToSynthesize">
-        <di:waypoint x="1011" y="280" />
-        <di:waypoint x="1106" y="280" />
-        <di:waypoint x="1106" y="160" />
-      </bpmndi:BPMNEdge>
-      <bpmndi:BPMNEdge id="BPMNEdge_f_toRecord" bpmnElement="f_toRecord">
-        <di:waypoint x="1156" y="120" />
-        <di:waypoint x="1256" y="120" />
-      </bpmndi:BPMNEdge>
-      <bpmndi:BPMNEdge id="BPMNEdge_f_toEnd" bpmnElement="f_toEnd">
-        <di:waypoint x="1356" y="120" />
-        <di:waypoint x="1456" y="120" />
+        <di:waypoint x="1266" y="280" />
+        <di:waypoint x="1416" y="280" />
+        <di:waypoint x="1416" y="160" />
       </bpmndi:BPMNEdge>
     </bpmndi:BPMNPlane>
   </bpmndi:BPMNDiagram>