diff --git a/‎.changeset/11772-flow-remove-node-edges.md‎
Lines changed: 13 additions & 0 deletions b/‎.changeset/11772-flow-remove-node-edges.md‎
Lines changed: 13 additions & 0 deletions
diff --git a/‎packages/app-shell/src/views/metadata-admin/i18n.ts‎
Lines changed: 5 additions & 0 deletions b/‎packages/app-shell/src/views/metadata-admin/i18n.ts‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎packages/app-shell/src/views/metadata-admin/inspectors/FlowNodeInspector.removeEdges-11772.test.tsx‎
Lines changed: 264 additions & 0 deletions b/‎packages/app-shell/src/views/metadata-admin/inspectors/FlowNodeInspector.removeEdges-11772.test.tsx‎
Lines changed: 264 additions & 0 deletions
diff --git a/‎packages/app-shell/src/views/metadata-admin/inspectors/FlowNodeInspector.tsx‎
Lines changed: 16 additions & 0 deletions b/‎packages/app-shell/src/views/metadata-admin/inspectors/FlowNodeInspector.tsx‎
Lines changed: 16 additions & 0 deletions
@@ -0,0 +1,13 @@
+---
+'@object-ui/app-shell': patch
+---
+
+The flow designer's Remove node takes the node's edges with it, and a new node never inherits the edges a removed one left behind (objectui#11772, the objectui half of objectstack#22088).
+
+Removing a node from the flow inspector left every edge that named it in the draft. The next node the designer added got the same id (`node_1`), so those edges re-attached to it, drawn on top of each other where the author saw one line. A published flow then ran that node once per edge: one record update created the same follow-up record three times.
+
+- **Remove node removes the node's edges in the same change.** When the node sat on a single path (one edge in, and one edge out with no condition, label or default flag), its predecessor is reconnected to its successor through the edge that led in, which keeps its id, condition, label and position. So removing a node that was inserted on a connection gives that connection back. A decision, a join, or a node whose edge out carries a condition or label loses its edges and is not reconnected. The canvas's Delete key makes the same removal.
+- **A new node never takes an id the editing session has seen**, on a node or at either end of an edge. A flow saved with an edge to a missing node no longer hands that edge to the next node added.
+- **The Problems panel flags a repeated connection**: an edge that joins the same two nodes the same way (the same type, condition, default flag and label) as an earlier edge. Each extra copy is its own row, and clicking the row selects that copy so the author can remove it. Two edges that join the same nodes differently, such as two decision branches leading to one node, are not flagged. An edge to a missing node was already flagged. Stored flows are not rewritten: these rows are how an author finds and repairs one.
+
+Nothing is added to the package entry: no export, prop, type member or language-pack key. The new Problems-panel row lives in the metadata-admin designer's own string tables (en and zh).
@@ -1942,6 +1942,9 @@ const ENGINE_STRINGS_EN: Record<string, string> = {
   'engine.flowProblems.empty': 'No problems — this flow is structurally valid.',
   'engine.flowProblems.sourceSchema': 'schema',
   'engine.flowProblems.sourceExpression': 'expression',
+  // objectui#11772 — one extra copy of a connection (`edgeRouteKey`): the
+  // engine follows every copy, so the target runs once per copy.
+  'engine.flowProblems.repeatedEdge': 'Connection {source} → {target} is repeated; the flow runs "{target}" once for each copy. Remove this copy.',
   // References side panel (ResourceEditPage) empty state.
   'engine.edit.refsScanning': 'Scanning references…',
   'engine.edit.refsEmptyTitle': 'No references found',
@@ -4913,6 +4916,8 @@ const ENGINE_STRINGS_ZH: Record<string, string> = {
   'engine.flowProblems.empty': '没有问题 —— 该流程结构有效。',
   'engine.flowProblems.sourceSchema': '架构',
   'engine.flowProblems.sourceExpression': '表达式',
+  // objectui#11772 — one extra copy of a connection (see the en row).
+  'engine.flowProblems.repeatedEdge': '连线 {source} → {target} 重复;流程会为每一条副本各运行一次 “{target}”。请删除这条副本。',
   // 引用关系侧栏(ResourceEditPage)空态。
   'engine.edit.refsScanning': '正在扫描引用…',
   'engine.edit.refsEmptyTitle': '未找到引用',
 
@@ -0,0 +1,264 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectui#11772 — the inspector's "Remove node" removes the edges that name
+ * the node in the SAME patch, and splices a node on a single path out
+ * (predecessor → successor). Every case presses the real Remove button and
+ * reads the patch the inspector hands its host.
+ *
+ * The canvas's Delete key makes the same removal through the same function
+ * (`edgesAfterNodeRemoval`); the last describe presses both on every fixture
+ * here and requires the two patches' edges to be equal.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup, fireEvent } from '@testing-library/react';
+
+vi.mock('../previews/useFlowNodePalette', () => ({
+  useActionConfigSchemas: () => ({}),
+  useFlowNodePalette: () => [],
+}));
+vi.mock('../previews/useObjectFields', () => ({
+  useObjectFields: () => ({ fields: [], loading: false, error: null }),
+}));
+
+import { FlowNodeInspector } from './FlowNodeInspector';
+import { FlowCanvas } from '../previews/FlowCanvas';
+import { t } from '../i18n';
+
+afterEach(cleanup);
+
+// The node inspectors read the object catalog (`/api/v1/meta/object`); answer
+// every read as an absent engine. Installed once for the whole file and never
+// torn down, so no read flushed after a test body can reach a real socket
+// (the shape `RecordDetailView.approvalDeclaredActions.test.tsx` documents).
+vi.stubGlobal(
+  'fetch',
+  vi.fn(async () => new Response('not found', { status: 404 })),
+);
+
+type Edge = { id?: string; source: string; target: string } & Record<string, unknown>;
+type Node = { id: string; type: string } & Record<string, unknown>;
+interface Fixture {
+  nodes: Node[];
+  edges: Edge[];
+}
+
+/** Press the inspector's Remove on `id`; the patch it hands the host. */
+function removeWithInspector(draft: Fixture, id: string): { nodes: Node[]; edges: Edge[] } {
+  const onPatch = vi.fn();
+  render(
+    <FlowNodeInspector
+      type="flow"
+      name="f"
+      draft={draft as unknown as Record<string, unknown>}
+      selection={{ kind: 'node', id }}
+      onPatch={onPatch}
+      onClearSelection={() => {}}
+      readOnly={false}
+      locale="en-US"
+    />,
+  );
+  fireEvent.click(screen.getByRole('button', { name: t('engine.inspector.flowNode.remove', 'en-US') }));
+  expect(onPatch).toHaveBeenCalledTimes(1);
+  cleanup();
+  return onPatch.mock.calls[0][0];
+}
+
+/** Press Delete on the canvas with `id` selected; the patch it hands the host. */
+function removeWithCanvas(draft: Fixture, id: string): { nodes: Node[]; edges: Edge[] } {
+  const onPatch = vi.fn();
+  render(
+    <FlowCanvas
+      nodes={draft.nodes}
+      edges={draft.edges as never}
+      editable
+      designMode
+      selectedId={id}
+      onSelect={() => {}}
+      onPatch={onPatch}
+    />,
+  );
+  fireEvent.keyDown(screen.getByRole('application', { name: t('engine.flowCanvas.canvas', 'en-US') }), { key: 'Delete' });
+  expect(onPatch).toHaveBeenCalledTimes(1);
+  cleanup();
+  return onPatch.mock.calls[0][0];
+}
+
+const naming = (edges: Edge[], id: string) => edges.filter((e) => e.source === id || e.target === id);
+
+const FIXTURES: Record<string, { draft: Fixture; remove: string }> = {
+  'a single path s → x → e': {
+    remove: 'x',
+    draft: {
+      nodes: [{ id: 's', type: 'start' }, { id: 'x', type: 'create_record' }, { id: 'e', type: 'end' }],
+      edges: [
+        { id: 'in', source: 's', target: 'x' },
+        { id: 'out', source: 'x', target: 'e' },
+      ],
+    },
+  },
+  'a node on a decision branch': {
+    remove: 'x',
+    draft: {
+      nodes: [
+        { id: 'd', type: 'decision' },
+        { id: 'x', type: 'create_record' },
+        { id: 'y', type: 'create_record' },
+        { id: 'e', type: 'end' },
+      ],
+      edges: [
+        { id: 'big', source: 'd', target: 'x', condition: 'amount > 100', label: 'Big' },
+        { id: 'else', source: 'd', target: 'y', isDefault: true },
+        { id: 'x-e', source: 'x', target: 'e' },
+        { id: 'y-e', source: 'y', target: 'e' },
+      ],
+    },
+  },
+  'a branch node (a decision with two edges out)': {
+    remove: 'd',
+    draft: {
+      nodes: [
+        { id: 's', type: 'start' },
+        { id: 'd', type: 'decision' },
+        { id: 'x', type: 'create_record' },
+        { id: 'y', type: 'create_record' },
+      ],
+      edges: [
+        { id: 's-d', source: 's', target: 'd' },
+        { id: 'big', source: 'd', target: 'x', condition: 'amount > 100' },
+        { id: 'else', source: 'd', target: 'y', isDefault: true },
+      ],
+    },
+  },
+  'a node whose one edge out is guarded': {
+    remove: 'x',
+    draft: {
+      nodes: [{ id: 's', type: 'start' }, { id: 'x', type: 'create_record' }, { id: 'e', type: 'end' }],
+      edges: [
+        { id: 'in', source: 's', target: 'x' },
+        { id: 'out', source: 'x', target: 'e', condition: 'ok == true' },
+      ],
+    },
+  },
+  'a node whose one edge out is labelled (an approval outcome)': {
+    remove: 'x',
+    draft: {
+      nodes: [{ id: 's', type: 'start' }, { id: 'x', type: 'approval' }, { id: 'e', type: 'end' }],
+      edges: [
+        { id: 'in', source: 's', target: 'x' },
+        { id: 'out', source: 'x', target: 'e', label: 'approve' },
+      ],
+    },
+  },
+  'a node entered only by a declared back-edge': {
+    remove: 'w',
+    draft: {
+      nodes: [{ id: 'a', type: 'approval' }, { id: 'w', type: 'wait' }, { id: 'e', type: 'end' }],
+      edges: [
+        { id: 'back', source: 'a', target: 'w', type: 'back' },
+        { id: 'out', source: 'w', target: 'e' },
+      ],
+    },
+  },
+  'a single path whose ends are already joined the same way': {
+    remove: 'x',
+    draft: {
+      nodes: [{ id: 's', type: 'start' }, { id: 'x', type: 'create_record' }, { id: 'e', type: 'end' }],
+      edges: [
+        { id: 'in', source: 's', target: 'x' },
+        { id: 'out', source: 'x', target: 'e' },
+        { id: 'direct', source: 's', target: 'e' },
+      ],
+    },
+  },
+  'a join (two edges in)': {
+    remove: 'x',
+    draft: {
+      nodes: [{ id: 'a', type: 'start' }, { id: 'b', type: 'create_record' }, { id: 'x', type: 'create_record' }, { id: 'e', type: 'end' }],
+      edges: [
+        { id: 'a-b', source: 'a', target: 'b' },
+        { id: 'a-x', source: 'a', target: 'x' },
+        { id: 'b-x', source: 'b', target: 'x' },
+        { id: 'x-e', source: 'x', target: 'e' },
+      ],
+    },
+  },
+  'a node whose edge in already names a missing node': {
+    remove: 'x',
+    draft: {
+      nodes: [{ id: 'x', type: 'create_record' }, { id: 'e', type: 'end' }],
+      edges: [
+        { id: 'in', source: 'ghost', target: 'x' },
+        { id: 'out', source: 'x', target: 'e' },
+      ],
+    },
+  },
+};
+
+describe('FlowNodeInspector — Remove node takes the edges that name it (objectui#11772)', () => {
+  for (const [name, { draft, remove }] of Object.entries(FIXTURES)) {
+    it(`${name}: no edge left names the removed node`, () => {
+      const patch = removeWithInspector(draft, remove);
+      expect(patch.nodes.map((n) => n.id)).toEqual(draft.nodes.map((n) => n.id).filter((id) => id !== remove));
+      expect(naming(patch.edges, remove)).toEqual([]);
+    });
+  }
+
+  it('a single path is spliced out: the edge in is kept, retargeted to the successor', () => {
+    const { edges } = removeWithInspector(FIXTURES['a single path s → x → e'].draft, 'x');
+    expect(edges).toEqual([{ id: 'in', source: 's', target: 'e' }]);
+  });
+
+  it('a decision branch through the removed node now leads to its successor, guard, label and position kept', () => {
+    const { edges } = removeWithInspector(FIXTURES['a node on a decision branch'].draft, 'x');
+    expect(edges).toEqual([
+      { id: 'big', source: 'd', target: 'e', condition: 'amount > 100', label: 'Big' },
+      { id: 'else', source: 'd', target: 'y', isDefault: true },
+      { id: 'y-e', source: 'y', target: 'e' },
+    ]);
+  });
+
+  it('a branch node loses its edges and nothing is reconnected', () => {
+    const { edges } = removeWithInspector(FIXTURES['a branch node (a decision with two edges out)'].draft, 'd');
+    expect(edges).toEqual([]);
+  });
+
+  for (const name of [
+    'a node whose one edge out is guarded',
+    'a node whose one edge out is labelled (an approval outcome)',
+    'a node entered only by a declared back-edge',
+    'a join (two edges in)',
+    'a node whose edge in already names a missing node',
+  ]) {
+    it(`${name}: dropped, not reconnected`, () => {
+      const { draft, remove } = FIXTURES[name];
+      const { edges } = removeWithInspector(draft, remove);
+      expect(edges).toEqual(draft.edges.filter((e) => e.source !== remove && e.target !== remove));
+    });
+  }
+
+  it('a splice never draws a second copy of a connection that already exists', () => {
+    const { edges } = removeWithInspector(FIXTURES['a single path whose ends are already joined the same way'].draft, 'x');
+    expect(edges).toEqual([{ id: 'direct', source: 's', target: 'e' }]);
+  });
+
+  it('while another node still carries the removed id, its edges are that node’s and stay', () => {
+    const draft: Fixture = {
+      nodes: [{ id: 's', type: 'start' }, { id: 'x', type: 'create_record', label: 'first' }, { id: 'x', type: 'create_record', label: 'second' }],
+      edges: [{ id: 'in', source: 's', target: 'x' }],
+    };
+    const patch = removeWithInspector(draft, 'x');
+    expect(patch.nodes.map((n) => n.label ?? n.id)).toEqual(['s', 'second']);
+    expect(patch.edges).toEqual(draft.edges);
+  });
+});
+
+describe('the canvas Delete key makes the very removal the inspector makes (objectui#11772)', () => {
+  for (const [name, { draft, remove }] of Object.entries(FIXTURES)) {
+    it(name, () => {
+      expect(removeWithCanvas(draft, remove).edges).toEqual(removeWithInspector(draft, remove).edges);
+    });
+  }
+});
@@ -64,6 +64,7 @@ import { NESTED_NODE_KIND, parseNestedNodeId, locateFlowNode, type InspectorFlow
 import { displayRegionLabel } from '../previews/flow-region-label.js';
 import type { FlowDesignerEdge } from '../previews/flow-canvas-layout.js';
 import { ScreenPreview } from '../previews/ScreenPreview.js';
+import { edgesAfterNodeRemoval } from '../previews/flow-problems.js';
 
 /**
  * The node and edge shapes this panel edits — ALIASED, never restated
@@ -421,8 +422,23 @@ export function FlowNodeInspector({ selection, draft, onPatch, onClearSelection,
     }
   };
 
+  // objectui#11772 — removing a node removes the edges that name it in the
+  // SAME patch, splicing a single-path node out (predecessor → successor): the
+  // canvas's Delete key makes the identical removal (`edgesAfterNodeRemoval`).
+  // Writing `null` to the node alone left every edge naming it behind, and the
+  // next node minted with that id inherited them all. Top-level only: a nested
+  // node has no Remove (its routing lives in its region, not on `draft.edges`).
   const remove = () => {
     const patch = loc?.write(null);
+    if (patch && !loc?.nested) {
+      const draftEdges = Array.isArray((draft as { edges?: unknown }).edges)
+        ? ((draft as { edges: FlowEdge[] }).edges)
+        : [];
+      const remaining = new Set(
+        (patch.nodes as Array<{ id?: unknown } | null>).flatMap((n) => (typeof n?.id === 'string' ? [n.id] : [])),
+      );
+      patch.edges = edgesAfterNodeRemoval(draftEdges, node.id, remaining);
+    }
     if (patch) onPatch(patch);
     onClearSelection();
   };