三面拆分⑮:图只留 v4 —— 拔自动重排修回节点身份,按钮改边号+标签

用户在编辑器里手调了几何(整体右下移 10px,三条定价来路并入 x170 合流下行道,
议价回边沿左缘绕行),存出 v2–v4;令「图只留 V4 版本」。落库前查出一处大 bug:

**编辑器每次改动都按几何拓扑自动重排活动编号**(renumberAll 挂 commandStack)。
卡点时代回跳不是真边、图无环,重排恰好稳定;上轮回跳成真边后图有环,
破环顺序把在座节点的 id 转圈重派 —— v4 里成本定价 id 变 A6、审批变 A4、议价变 A5
(code 显示无恙,身份已漂)。id 是节点身份:在途按它钉定义、映射按它寻址、
异常按它定位,不许因挪布局而漂移。

处置:
- **拔除自动重排**:编号落子时铸定(mintNodeId 取下一空号),此后恒定;
  orderActivityIds / swapIdTokens 死代码删除
- **修复 v4**:id permute 回对齐编号(A4=定价 A5=审批 A6=议价),语义按种子重建
  (审批 reject 声明与 reopen 标记在漂移中已损,一并复原),几何原样保留用户手调
- **外科手术**:删 v1–v3,v4 成唯一生效版;种子几何回灌 v4 手调版,
  重种实证幂等(「已在库,内容未变 —— 不存新版」)
- **拣选条按钮:边号 + 标签**(E4 直接定价),不再显示边方向;方向在属性卡标题里看

八例端到端真库全绿,五闸退出码全过。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KeDBx2PHLavbURXB8LJJ7m

apps/web/src/features/gov-process/internal/panel.tsx

@@ -939,7 +939,7 @@ function FlowLab({
                 onClick={() => { setSelEdge(selEdge === i ? null : i); setSel(null); }}
               >
                 <b className="g-mono">{e.code ?? `边${i + 1}`}</b>
-                {e.from}→{e.to}
+                {e.label ?? ''}
               </button>
             ))}
           </div>

apps/web/src/shared/gov/flow/flow-editor-core.ts

@@ -38,7 +38,7 @@ import {
   type FlowNodeKind,
   type FlowTone,
 } from "./flow-layout.ts";
-import { cleanPoints, mintNodeId, orderActivityIds, seedManualGraph, snap, swapIdTokens, type OrderNode } from "./manual-flow.ts";
+import { cleanPoints, mintNodeId, seedManualGraph, snap } from "./manual-flow.ts";
 import { arrowHeadPoints, CAPTION_STYLE, FLOW_MONO, paintNode, svgEl, TONE_COLOR } from "./flow-node-paint.ts";
 
 /**
@@ -809,51 +809,14 @@ export function createFlowEditor(initial: FlowGraph | null | undefined, options:
     }
   }
 
-  const renumberAll = () => {
-    const shapes = elementRegistry
-      .getAll()
-      .filter((el: Any) => el.parent && !el.waypoints && !el.labelTarget && el.businessObject?.id);
-    const nodes: OrderNode[] = shapes.map((el: Any) => ({
-      id: el.businessObject.id,
-      kind: el.businessObject.kind,
-      x: el.x + el.width / 2,
-      y: el.y + el.height / 2,
-    }));
-    const edges = elementRegistry
-      .getAll()
-      .filter((el: Any) => el.waypoints && el.parent && el.source?.businessObject?.id && el.target?.businessObject?.id)
-      .map((el: Any) => ({ from: el.source.businessObject.id, to: el.target.businessObject.id }));
-    const mapping = orderActivityIds(nodes, edges);
-    if (mapping.size === 0) return;
-    const changed: Any[] = [];
-    for (const el of shapes) {
-      const bo = el.businessObject as FlowNode;
-      let touched = false;
-      if (mapping.has(bo.id)) {
-        bo.id = mapping.get(bo.id)!;
-        touched = true;
-      }
-      if (bo.to && mapping.has(bo.to)) {
-        bo.to = mapping.get(bo.to)!;
-        touched = true;
-      }
-      if (bo.basis) {
-        const swapped = swapIdTokens(bo.basis, mapping);
-        if (swapped !== bo.basis) {
-          bo.basis = swapped;
-          touched = true;
-        }
-      }
-      if (touched) {
-        changed.push(el);
-        const label = labelOf(el);
-        if (label) changed.push(label);
-      }
-    }
-    if (changed.length) eventBus.fire("elements.changed", { elements: changed });
-  };
-  renumberAll();
-  eventBus.on("commandStack.changed", renumberAll);
+  /*
+   * **不自动重排编号**(2026-07-28 第四轮拔除)。
+   * 旧机制「几何即排序把手」在卡点时代成立 —— 回跳画成牌子,图无环,拓扑重排稳定;
+   * 回跳成真边后图**有环**,破环顺序会把在座节点的 id 转圈重派(实测:成本定价
+   * A4→A6、审批 A4、议价 A5),而 id 是**节点身份**:在途工作流按它钉定义、
+   * 边映射按它寻址、异常按它定位 —— 身份不许因挪动布局而漂移。
+   * 编号在落子时铸定(mintNodeId 取下一个空号),此后恒定;想换号,删了重画。
+   */
 
   const serialize = (): { graph: FlowGraph; idMap: Record<string, string> } => {
     // 画布是无限域(可有负坐标)——先求整体包围,统一平移到非负(保相对几何/正交),再吸附珊格。

apps/web/src/shared/gov/flow/manual-flow.ts

@@ -133,84 +133,7 @@ const ID_PREFIX: Partial<Record<FlowNodeKind, string>> = {
 
 /* ---- 活动自动顺序编号:沿流向拓扑序,几何 (y,x) 决胜 ---- */
 
-export interface OrderNode {
-  id: string;
-  kind: FlowNodeKind;
-  /** 节点中心(决胜用)。 */
-  x: number;
-  y: number;
-}
 
-/**
- * 计算活动的规范编号 A1..An:从入度 0 的节点(起始)沿连线做拓扑遍历,
- * 同时就绪者按 (y,x) 取先(上面的先、左边的先)——汇合点等所有来路编号完才轮到,
- * 所以网关分支链先占号、汇后主线随后,与剧本世界的编号纪律同构;
- * 几何即排序把手:想换号,挪节点。环用 (剩余入度,y,x) 最小者破;
- * 不可达的活动排在最后。只返回**有变化**的 旧id→新id 映射。
- */
-export function orderActivityIds(nodes: OrderNode[], edges: Array<{ from: string; to: string }>): Map<string, string> {
-  const byId = new Map(nodes.map((n) => [n.id, n]));
-  const indeg = new Map<string, number>(nodes.map((n) => [n.id, 0]));
-  const out = new Map<string, string[]>();
-  for (const e of edges) {
-    if (!byId.has(e.from) || !byId.has(e.to) || e.from === e.to) continue;
-    out.set(e.from, [...(out.get(e.from) ?? []), e.to]);
-    indeg.set(e.to, (indeg.get(e.to) ?? 0) + 1);
-  }
-  const geo = (id: string): [number, number] => {
-    const n = byId.get(id)!;
-    return [n.y, n.x];
-  };
-  const byGeo = (a: string, b: string) => geo(a)[0] - geo(b)[0] || geo(a)[1] - geo(b)[1];
-
-  const visited = new Set<string>();
-  const ready = new Set<string>(nodes.filter((n) => (indeg.get(n.id) ?? 0) === 0).map((n) => n.id));
-  const mapping = new Map<string, string>();
-  let seq = 0;
-
-  const visit = (id: string) => {
-    visited.add(id);
-    ready.delete(id);
-    const node = byId.get(id)!;
-    if (node.kind === "activity") mapping.set(id, `A${++seq}`);
-    for (const t of out.get(id) ?? []) {
-      indeg.set(t, (indeg.get(t) ?? 1) - 1);
-      if ((indeg.get(t) ?? 0) <= 0 && !visited.has(t)) ready.add(t);
-    }
-  };
-
-  while (visited.size < nodes.length) {
-    const candidates = [...ready].filter((id) => !visited.has(id));
-    if (candidates.length > 0) {
-      visit(candidates.sort(byGeo)[0]!);
-    } else {
-      // 环/汇合死锁:挑未访问中 (剩余入度, y, x) 最小者破环。
-      const rest = nodes.filter((n) => !visited.has(n.id)).map((n) => n.id);
-      rest.sort((a, b) => (indeg.get(a) ?? 0) - (indeg.get(b) ?? 0) || byGeo(a, b));
-      visit(rest[0]!);
-    }
-  }
-
-  for (const [oldId, newId] of [...mapping]) {
-    if (oldId === newId) mapping.delete(oldId);
-  }
-  return mapping;
-}
-
-/** 文本里的 id 引用按映射换号:占位符两段式(防级联),长 id 先换(防 A10 被 A1 误伤)。 */
-export function swapIdTokens(text: string, mapping: ReadonlyMap<string, string>): string {
-  const pairs = [...mapping.entries()].filter(([from, to]) => from !== to).sort((a, b) => b[0].length - a[0].length);
-  let outText = text;
-  pairs.forEach(([from], i) => {
-    outText = outText.split(from).join(`⟦${i}⟧`);
-  });
-  pairs.forEach(([, to], i) => {
-    outText = outText.split(`⟦${i}⟧`).join(to);
-  });
-  return outText;
-}
-
-/** 铸新编号:前缀取未用最小号;起/止先用 S/E,再 S2/E2…;避开 reserved(下钻 operations 键)。 */
 export function mintNodeId(kind: FlowNodeKind, graph: FlowGraph, reserved: ReadonlySet<string>): string {
   const used = new Set([...graph.nodes.map((n) => n.id), ...reserved]);
   if (kind === "start" || kind === "end") {