diff --git a/.nx/version-plans/flow-copy-paste-undo.md b/.nx/version-plans/flow-copy-paste-undo.md
new file mode 100644
index 000000000..1b0afa39c
--- /dev/null
+++ b/.nx/version-plans/flow-copy-paste-undo.md
@@ -0,0 +1,5 @@
+---
+desktop: minor
+---
+
+Add flow node copy/paste and canvas undo/redo support.
diff --git a/packages/client/package.json b/packages/client/package.json
index a298c82e7..6a5a6992b 100644
--- a/packages/client/package.json
+++ b/packages/client/package.json
@@ -33,7 +33,6 @@
     "@hookform/resolvers": "catalog:",
     "@lezer/highlight": "catalog:",
     "@lezer/lr": "catalog:",
-    "@openreplay/tracker": "catalog:",
     "@prettier/plugin-xml": "catalog:",
     "@react-aria/collections": "catalog:",
     "@standard-schema/spec": "catalog:",
diff --git a/packages/client/src/app/index.tsx b/packages/client/src/app/index.tsx
index c1bb1c681..1ed04a8b9 100644
--- a/packages/client/src/app/index.tsx
+++ b/packages/client/src/app/index.tsx
@@ -11,7 +11,6 @@ import { makeToastQueue } from '@the-dev-tools/ui/toast';
 import { ApiCollections, ApiTransport } from '~/shared/api';
 import { runtimeAtom } from '~/shared/lib/runtime';
 import { RouterContext } from './context';
-import { startOpenReplay } from './open-replay';
 import { router } from './router';
 import { initUmami } from './umami';
 
@@ -23,7 +22,6 @@ const appAtom = runtimeAtom.atom(
 
     // Telemetry startup should never block app rendering.
     void Runtime.runPromise(runtime)(initUmami).catch(() => undefined);
-    void Runtime.runPromise(runtime)(startOpenReplay).catch(() => undefined);
 
     yield* ApiCollections;
     const transport = yield* ApiTransport;
diff --git a/packages/client/src/app/open-replay.tsx b/packages/client/src/app/open-replay.tsx
deleted file mode 100644
index 8305e8c20..000000000
--- a/packages/client/src/app/open-replay.tsx
+++ /dev/null
@@ -1,42 +0,0 @@
-import OpenReplayTracker from '@openreplay/tracker';
-import { Config, Data, Effect, Option, pipe, Redacted } from 'effect';
-
-export class StartOpenReplayError extends Data.TaggedError('StartOpenReplayError')<{ reason: string }> {}
-
-export const startOpenReplay = Effect.gen(function* () {
-  const configNamespace = Config.nested('PUBLIC_OPEN_REPLAY');
-
-  const track = yield* pipe(
-    Config.boolean('TRACK'),
-    configNamespace,
-    Config.orElse(() => Config.succeed(false)),
-  );
-  if (!track) return;
-
-  const projectKey = yield* pipe(Config.redacted('PROJECT_KEY'), configNamespace);
-  const tracker = new OpenReplayTracker({
-    projectKey: Redacted.value(projectKey),
-
-    __DISABLE_SECURE_MODE: true,
-
-    network: {
-      captureInIframes: true,
-      capturePayload: true,
-      failuresOnly: false,
-      ignoreHeaders: false,
-      sessionTokenHeader: false,
-    },
-  });
-
-  const sessionName = yield* pipe(Config.string('SESSION_NAME'), configNamespace, Config.option);
-  Option.map(sessionName, (_) => void tracker.setMetadata('session-name', _));
-
-  const userId = yield* pipe(Config.string('USER_ID'), configNamespace, Config.option);
-  Option.map(userId, (_) => void tracker.setUserID(_));
-
-  const result = yield* Effect.promise(() => tracker.start());
-  if (!result.success) return yield* Effect.fail(new StartOpenReplayError({ reason: result.reason }));
-  yield* Effect.logInfo('Tracking started', { ...result, sessionName, userId });
-
-  yield* Effect.addFinalizer(() => Effect.sync(() => tracker.stop()));
-});
diff --git a/packages/client/src/pages/flow/agent-panel.tsx b/packages/client/src/pages/flow/agent-panel.tsx
index 118484350..71a08e8c3 100644
--- a/packages/client/src/pages/flow/agent-panel.tsx
+++ b/packages/client/src/pages/flow/agent-panel.tsx
@@ -1,5 +1,4 @@
 import { eq, useLiveQuery } from '@tanstack/react-db';
-import * as XF from '@xyflow/react';
 import { Ulid } from 'id128';
 import { FormEvent, KeyboardEvent, use, useEffect, useMemo, useRef, useState } from 'react';
 import { FiArrowUp, FiChevronUp, FiEdit, FiSettings, FiX } from 'react-icons/fi';
@@ -12,7 +11,7 @@ import { type Message, type ToolCall, useAgentChat } from '~/features/agent';
 import { type AgentProvider, useAgentProviderKey } from '~/features/agent/use-agent-provider-key';
 import { useApiCollection } from '~/shared/api';
 import { FlowContext } from './context';
-import { nodeClientCollection } from './node';
+import { useFlowSelection } from './selection';
 
 // ---------------------------------------------------------------------------
 // Tool call display helpers
@@ -87,10 +86,7 @@ const PROVIDER_OPTIONS: Record<
 export const AgentPanel = () => {
   const { flowId, setAgentPanelOpen } = use(FlowContext);
   const { apiKey, provider, setApiKey, setProvider } = useAgentProviderKey();
-  const selectedNodeIds = XF.useStore(
-    (s) => s.nodes.filter((n) => n.selected).map((n) => n.id),
-    (a, b) => a.length === b.length && a.every((id, i) => id === b[i]),
-  );
+  const { deselectAll, deselectNodes, selectedNodeIds } = useFlowSelection();
   const { cancel, clearMessages, error, isLoading, messages, sendMessage, streamingContent } = useAgentChat({
     apiKey,
     flowId,
@@ -231,7 +227,13 @@ export const AgentPanel = () => {
             className={tw`m-2 mt-0 rounded-[4px] border border-(--border-1) bg-(--surface-4) px-2.5 py-1.5`}
             data-agent-composer
           >
-            {selectedNodeIds.length > 0 && <SelectedNodesBar selectedNodeIds={selectedNodeIds} />}
+            {selectedNodeIds.length > 0 && (
+              <SelectedNodesBar
+                deselectAll={deselectAll}
+                deselectNodes={deselectNodes}
+                selectedNodeIds={selectedNodeIds}
+              />
+            )}
             <div className={tw`flex items-end gap-2`}>
               <textarea
                 className={tw`
@@ -279,7 +281,13 @@ export const AgentPanel = () => {
   );
 };
 
-const SelectedNodesBar = ({ selectedNodeIds }: { selectedNodeIds: string[] }) => {
+interface SelectedNodesBarProps {
+  deselectAll: () => void;
+  deselectNodes: (ids: string[]) => void;
+  selectedNodeIds: string[];
+}
+
+const SelectedNodesBar = ({ deselectAll, deselectNodes, selectedNodeIds }: SelectedNodesBarProps) => {
   const { flowId } = use(FlowContext);
   const nodeCollection = useApiCollection(NodeCollectionSchema);
 
@@ -301,16 +309,6 @@ const SelectedNodesBar = ({ selectedNodeIds }: { selectedNodeIds: string[] }) =>
 
   if (selectedNodes.length === 0) return null;
 
-  const handleDeselect = (id: string) => {
-    nodeClientCollection.update(id, (_) => (_.selected = false));
-  };
-
-  const handleClearAll = () => {
-    for (const id of selectedNodeIds) {
-      nodeClientCollection.update(id, (_) => (_.selected = false));
-    }
-  };
-
   return (
     <div className={tw`mb-1.5 flex flex-wrap items-center gap-1.5 border-b border-(--border-1) pb-1.5`}>
       {selectedNodes.length > 5 ? (
@@ -334,7 +332,7 @@ const SelectedNodesBar = ({ selectedNodeIds }: { selectedNodeIds: string[] }) =>
             <span className={tw`max-w-[120px] truncate`}>{node.name}</span>
             <button
               className={tw`rounded-sm text-(--text-muted) hover:text-(--text-primary)`}
-              onClick={() => void handleDeselect(node.id)}
+              onClick={() => void deselectNodes([node.id])}
               type='button'
             >
               <FiX className={tw`size-3`} />
@@ -345,7 +343,7 @@ const SelectedNodesBar = ({ selectedNodeIds }: { selectedNodeIds: string[] }) =>
       {selectedNodes.length >= 2 && (
         <button
           className={tw`text-[11px] text-(--text-muted) hover:text-(--text-secondary)`}
-          onClick={handleClearAll}
+          onClick={deselectAll}
           type='button'
         >
           Clear all
diff --git a/packages/client/src/pages/flow/context.tsx b/packages/client/src/pages/flow/context.tsx
index fa11add62..6ec06e88e 100644
--- a/packages/client/src/pages/flow/context.tsx
+++ b/packages/client/src/pages/flow/context.tsx
@@ -1,4 +1,5 @@
 import { createContext, Dispatch, ReactNode, SetStateAction } from 'react';
+import { UndoStack } from './undo';
 
 export interface FlowContext {
   agentPanelOpen?: boolean;
@@ -6,6 +7,7 @@ export interface FlowContext {
   isReadOnly?: boolean;
   setAgentPanelOpen?: Dispatch<SetStateAction<boolean>>;
   setSidebar?: Dispatch<SetStateAction<ReactNode>>;
+  undoStack?: UndoStack;
 }
 
 export const FlowContext = createContext({} as FlowContext);
diff --git a/packages/client/src/pages/flow/edge.tsx b/packages/client/src/pages/flow/edge.tsx
index b4172044e..07d726b14 100644
--- a/packages/client/src/pages/flow/edge.tsx
+++ b/packages/client/src/pages/flow/edge.tsx
@@ -34,7 +34,7 @@ export const edgeClientCollection = createCollection(
 );
 
 export const useEdgeState = () => {
-  const { flowId } = useContext(FlowContext);
+  const { flowId, undoStack } = useContext(FlowContext);
 
   const edgeServerCollection = useApiCollection(EdgeCollectionSchema);
 
@@ -77,15 +77,30 @@ export const useEdgeState = () => {
     });
 
     if (changes.remove?.length) {
+      // Snapshot edge data for undo before deleting
+      const edgeSnapshots = changes.remove
+        .map((_) => {
+          const edgeId = Ulid.fromCanonical(_.id).bytes;
+          const key = edgeServerCollection.utils.getKey({ edgeId });
+          const data = edgeServerCollection.get(key);
+          if (!data) return null;
+          return {
+            flowId: data.flowId,
+            sourceHandle: data.sourceHandle,
+            sourceId: data.sourceId,
+            targetId: data.targetId,
+          };
+        })
+        .filter((_) => _ !== null);
+      if (edgeSnapshots.length > 0) undoStack?.push({ edges: edgeSnapshots, type: 'edge-delete' });
+
       pipe(
         changes.remove.map((_) => edgeServerCollection.utils.getKeyObject({ edgeId: Ulid.fromCanonical(_.id).bytes })),
         edgeServerCollection.utils.delete,
       );
 
-      pipe(
-        changes.remove.map((_) => _.id),
-        edgeClientCollection.delete,
-      );
+      const clientKeys = changes.remove.map((_) => _.id).filter((_) => edgeClientCollection.has(_));
+      if (clientKeys.length > 0) pipe(clientKeys, edgeClientCollection.delete);
     }
   };
 
diff --git a/packages/client/src/pages/flow/edit.tsx b/packages/client/src/pages/flow/edit.tsx
index 297df801b..ba87f2347 100644
--- a/packages/client/src/pages/flow/edit.tsx
+++ b/packages/client/src/pages/flow/edit.tsx
@@ -4,7 +4,7 @@ import { useMatchRoute, useRouter } from '@tanstack/react-router';
 import * as XF from '@xyflow/react';
 import { Duration, Match, pipe } from 'effect';
 import { Ulid } from 'id128';
-import { PropsWithChildren, ReactNode, use, useRef, useState } from 'react';
+import { PropsWithChildren, ReactNode, use, useCallback, useEffect, useRef, useState } from 'react';
 import { useDrop } from 'react-aria';
 import {
   Button as AriaButton,
@@ -19,7 +19,14 @@ import { FiAlertTriangle, FiClock, FiCpu, FiMinus, FiMoreHorizontal, FiPlus, FiS
 import { Group as PanelGroup, Panel as ResizablePanel } from 'react-resizable-panels';
 import { twJoin } from 'tailwind-merge';
 import { FileKind } from '@the-dev-tools/spec/buf/api/file_system/v1/file_system_pb';
-import { FlowSchema, FlowService, HandleKind, NodeKind, NodeSchema } from '@the-dev-tools/spec/buf/api/flow/v1/flow_pb';
+import {
+  FlowSchema,
+  FlowService,
+  HandleKind,
+  NodeKind,
+  NodeSchema,
+  ReferenceMode,
+} from '@the-dev-tools/spec/buf/api/flow/v1/flow_pb';
 import { FileCollectionSchema } from '@the-dev-tools/spec/tanstack-db/v1/api/file_system';
 import {
   EdgeCollectionSchema,
@@ -74,6 +81,8 @@ import { ForEachNode, ForEachSettings } from './nodes/for-each';
 import { HttpNode, HttpSettings } from './nodes/http';
 import { JavaScriptNode, JavaScriptSettings } from './nodes/javascript';
 import { ManualStartNode } from './nodes/manual-start';
+import { useFlowSelection } from './selection';
+import { useUndoStack } from './undo';
 import { useViewport, VIEWPORT_MAX_ZOOM, VIEWPORT_MIN_ZOOM } from './viewport';
 
 export const nodeTypes: XF.NodeTypes = {
@@ -94,9 +103,10 @@ export const FlowEditPage = () => {
 
   const [sidebar, setSidebar] = useState<ReactNode>(null);
   const [agentPanelOpen, setAgentPanelOpen] = useState(false);
+  const undoStack = useUndoStack(flowId);
 
   return (
-    <FlowContext.Provider value={{ agentPanelOpen, flowId, setAgentPanelOpen, setSidebar }}>
+    <FlowContext.Provider value={{ agentPanelOpen, flowId, setAgentPanelOpen, setSidebar, undoStack }}>
       <XF.ReactFlowProvider>
         <div className={tw`flex h-full flex-col`}>
           <TopBarWithControls />
@@ -142,9 +152,10 @@ export const Flow = ({ children }: PropsWithChildren) => {
 
   const nodeEditDialog = useNodeEditDialog();
 
-  const { getNodes, screenToFlowPosition } = XF.useReactFlow();
+  const { getNodes, getViewport, screenToFlowPosition } = XF.useReactFlow();
+  const { deselectAll, selectNodes } = useFlowSelection();
 
-  const { flowId, isReadOnly = false, setSidebar } = use(FlowContext);
+  const { flowId, isReadOnly = false, setSidebar, undoStack } = use(FlowContext);
 
   const { duration } =
     useLiveQuery(
@@ -158,7 +169,7 @@ export const Flow = ({ children }: PropsWithChildren) => {
 
   const ref = useRef<HTMLDivElement>(null);
 
-  const { nodes, onNodesChange } = useNodesState();
+  const { handlePositionChange, nodes, onNodeDragStart, onNodeDragStop, onNodesChange } = useNodesState();
   const { edges, onEdgesChange } = useEdgeState();
   const { onViewportChange, viewport } = useViewport();
 
@@ -175,13 +186,19 @@ export const Flow = ({ children }: PropsWithChildren) => {
     if (sourceHandle === HandleKind.AI_PROVIDER && targetNode?.kind !== NodeKind.AI_PROVIDER) return;
     if (sourceHandle === HandleKind.AI_MEMORY && targetNode?.kind !== NodeKind.AI_MEMORY) return;
 
+    const newEdgeId = Ulid.generate().bytes;
     edgeCollection.utils.insert({
-      edgeId: Ulid.generate().bytes,
+      edgeId: newEdgeId,
       flowId,
       sourceHandle,
       sourceId: Ulid.fromCanonical(_.source).bytes,
       targetId,
     });
+    undoStack?.push({
+      edgeIds: [newEdgeId],
+      edges: [{ flowId, sourceHandle, sourceId: Ulid.fromCanonical(_.source).bytes, targetId }],
+      type: 'edge-insert',
+    });
   };
 
   const onConnectEnd: XF.OnConnectEnd = (event, { fromHandle, fromNode, isValid }) => {
@@ -200,6 +217,185 @@ export const Flow = ({ children }: PropsWithChildren) => {
     setSidebar?.(<Sidebar handleKind={handleKind} position={position} sourceId={sourceId} />);
   };
 
+  const { transport } = routes.root.useRouteContext();
+
+  // Set up undo executors
+  useEffect(() => {
+    undoStack?.setExecutors({
+      deleteEdges: (edgeIds) => {
+        const keys = edgeIds.map((edgeId) => edgeCollection.utils.getKeyObject({ edgeId }));
+        edgeCollection.utils.delete(keys);
+      },
+      deleteNodes: (nodeIds) => {
+        // Delete edges connected to these nodes before deleting the nodes
+        const nodeIdSet = new Set(nodeIds.map((id) => Ulid.construct(id).toCanonical()));
+        const connectedEdgeKeys = [...edgeCollection.values()]
+          .filter(
+            (e) =>
+              nodeIdSet.has(Ulid.construct(e.sourceId).toCanonical()) ||
+              nodeIdSet.has(Ulid.construct(e.targetId).toCanonical()),
+          )
+          .map((e) => edgeCollection.utils.getKeyObject({ edgeId: e.edgeId }));
+        if (connectedEdgeKeys.length > 0) edgeCollection.utils.delete(connectedEdgeKeys);
+
+        const keys = nodeIds.map((nodeId) => nodeCollection.utils.getKeyObject({ nodeId }));
+        nodeCollection.utils.delete(keys);
+      },
+      deselectAll,
+      insertEdge: (edge) => {
+        const edgeId = Ulid.generate().bytes;
+        edgeCollection.utils.insert({
+          edgeId,
+          flowId: edge.flowId,
+          sourceHandle: edge.sourceHandle,
+          sourceId: edge.sourceId,
+          targetId: edge.targetId,
+        });
+        return edgeId;
+      },
+      pasteNodes: async (yaml, fId, offset) => {
+        const res = await request({
+          input: {
+            flowId: fId,
+            offsetX: offset.x,
+            offsetY: offset.y,
+            referenceMode: ReferenceMode.CREATE_COPY,
+            yaml,
+          },
+          method: FlowService.method.flowNodesPaste,
+          transport,
+        });
+        return res.message.nodeIds;
+      },
+      updateNodePositions: (nodes) => {
+        for (const n of nodes) {
+          const nodeId = Ulid.fromCanonical(n.id).bytes;
+          const key = nodeCollection.utils.getKey({ nodeId });
+          if (nodeCollection.has(key)) {
+            handlePositionChange({ id: n.id, position: n.position, type: 'position' });
+          }
+        }
+      },
+    });
+  }, [deselectAll, edgeCollection, flowId, handlePositionChange, nodeCollection, transport, undoStack]);
+
+  // Track source flow for smart paste positioning
+  const copySourceFlowIdRef = useRef<null | Uint8Array>(null);
+
+  // Copy/paste keyboard handlers
+  const handleCopy = useCallback(async () => {
+    const selectedIds = getNodes()
+      .filter((n) => n.selected)
+      .map((n) => Ulid.fromCanonical(n.id).bytes);
+    if (selectedIds.length === 0) return;
+
+    try {
+      const res = await request({
+        input: { flowId, nodeIds: selectedIds },
+        method: FlowService.method.flowNodesCopy,
+        transport,
+      });
+      copySourceFlowIdRef.current = flowId;
+      await navigator.clipboard.writeText(res.message.yaml);
+    } catch (e) {
+      console.error('Copy failed:', e);
+    }
+  }, [flowId, getNodes, transport]);
+
+  const handlePaste = useCallback(async () => {
+    if (isReadOnly) return;
+
+    let yaml: string;
+    try {
+      yaml = await navigator.clipboard.readText();
+    } catch {
+      return;
+    }
+
+    if (!yaml || (!yaml.includes('steps:') && !yaml.includes('flows:'))) return;
+
+    // Smart positioning: same flow → 200px below selection, different flow → viewport center
+    const isSameFlow =
+      copySourceFlowIdRef.current !== null &&
+      flowId.length === copySourceFlowIdRef.current.length &&
+      flowId.every((b, i) => b === copySourceFlowIdRef.current![i]);
+
+    let offsetX = 0;
+    let offsetY = 200;
+
+    if (!isSameFlow) {
+      // Parse node positions from YAML to compute centroid
+      const posXMatches = [...yaml.matchAll(/position_x:\s*([-\d.]+)/g)].map((_) => parseFloat(_[1]));
+      const posYMatches = [...yaml.matchAll(/position_y:\s*([-\d.]+)/g)].map((_) => parseFloat(_[1]));
+
+      const container = ref.current;
+      if (container && posXMatches.length > 0 && posYMatches.length > 0) {
+        const centroidX = posXMatches.reduce((a, b) => a + b, 0) / posXMatches.length;
+        const centroidY = posYMatches.reduce((a, b) => a + b, 0) / posYMatches.length;
+
+        const { x: vx, y: vy, zoom } = getViewport();
+        const { height, width } = container.getBoundingClientRect();
+
+        // Viewport center in flow coordinates, offset from centroid
+        offsetX = -vx / zoom + width / zoom / 2 - centroidX;
+        offsetY = -vy / zoom + height / zoom / 2 - centroidY;
+      }
+    }
+
+    try {
+      const res = await request({
+        input: { flowId, offsetX, offsetY, referenceMode: ReferenceMode.CREATE_COPY, yaml },
+        method: FlowService.method.flowNodesPaste,
+        transport,
+      });
+
+      undoStack?.push({
+        flowId,
+        nodeIds: res.message.nodeIds,
+        pasteOffset: { x: offsetX, y: offsetY },
+        type: 'paste',
+        yaml,
+      });
+      deselectAll();
+      const pastedCanonicals = res.message.nodeIds.map((id) => Ulid.construct(id).toCanonical());
+      selectNodes(pastedCanonicals);
+    } catch (e) {
+      console.error('Paste failed:', e);
+    }
+  }, [deselectAll, flowId, getViewport, isReadOnly, selectNodes, transport, undoStack]);
+
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      // Skip if focus is inside an input, textarea, or contenteditable
+      const target = e.target as HTMLElement;
+      if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) return;
+
+      const mod = e.metaKey || e.ctrlKey;
+      if (!mod) return;
+      const key = e.key.toLowerCase();
+
+      if (key === 'c') {
+        e.preventDefault();
+        void handleCopy();
+      }
+      if (key === 'v') {
+        e.preventDefault();
+        void handlePaste();
+      }
+      if (key === 'z' && !e.shiftKey) {
+        e.preventDefault();
+        void undoStack?.undo();
+      }
+      if ((key === 'z' && e.shiftKey) || key === 'y') {
+        e.preventDefault();
+        void undoStack?.redo();
+      }
+    };
+
+    document.addEventListener('keydown', handleKeyDown);
+    return () => void document.removeEventListener('keydown', handleKeyDown);
+  }, [handleCopy, handlePaste, undoStack]);
+
   const { dropProps } = useDrop({
     onDrop: async ({ items, x, y }) => {
       const [item] = items;
@@ -283,6 +479,8 @@ export const Flow = ({ children }: PropsWithChildren) => {
           const nodeId = Ulid.fromCanonical(node.id);
           void nodeEditDialog.open(nodeId.bytes);
         }}
+        onNodeDragStart={onNodeDragStart}
+        onNodeDragStop={onNodeDragStop}
         onNodesChange={onNodesChange}
         onViewportChange={onViewportChange}
         panOnDrag={[1, 2]}
diff --git a/packages/client/src/pages/flow/node.tsx b/packages/client/src/pages/flow/node.tsx
index 518832d47..4fb6b6ad8 100644
--- a/packages/client/src/pages/flow/node.tsx
+++ b/packages/client/src/pages/flow/node.tsx
@@ -11,7 +11,7 @@ import {
 import * as XF from '@xyflow/react';
 import { Array, Match, Option, pipe, Schema } from 'effect';
 import { Ulid } from 'id128';
-import { ReactNode, useContext, useState } from 'react';
+import { ReactNode, useCallback, useContext, useRef, useState } from 'react';
 import { Button as AriaButton, Key, Tooltip, TooltipTrigger, Tree } from 'react-aria-components';
 import { FiX } from 'react-icons/fi';
 import { TbAlertTriangle, TbCancel, TbRefresh } from 'react-icons/tb';
@@ -24,7 +24,11 @@ import {
   NodeExecutionSchema,
   NodeSchema,
 } from '@the-dev-tools/spec/buf/api/flow/v1/flow_pb';
-import { NodeCollectionSchema, NodeExecutionCollectionSchema } from '@the-dev-tools/spec/tanstack-db/v1/api/flow';
+import {
+  EdgeCollectionSchema,
+  NodeCollectionSchema,
+  NodeExecutionCollectionSchema,
+} from '@the-dev-tools/spec/tanstack-db/v1/api/flow';
 import { Button } from '@the-dev-tools/ui/button';
 import { CheckIcon } from '@the-dev-tools/ui/icons';
 import { SearchEmptyIllustration } from '@the-dev-tools/ui/illustrations';
@@ -56,8 +60,9 @@ export const nodeClientCollection = createCollection(
 
 export const useNodesState = () => {
   const { transport } = routes.root.useRouteContext();
-  const { flowId } = useContext(FlowContext);
+  const { flowId, undoStack } = useContext(FlowContext);
 
+  const edgeServerCollection = useApiCollection(EdgeCollectionSchema);
   const nodeServerCollection = useApiCollection(NodeCollectionSchema);
 
   const items: XF.Node[] = useLiveQuery(
@@ -114,6 +119,31 @@ export const useNodesState = () => {
     strategy: debounceStrategy({ wait: 500 }),
   });
 
+  // Track drag-start positions for undo via onNodeDragStart/onNodeDragStop
+  const dragStartPositions = useRef<Map<string, { x: number; y: number }>>(new Map());
+
+  const onNodeDragStart: XF.OnNodeDrag = useCallback((_event, _node, nodes) => {
+    for (const n of nodes) {
+      dragStartPositions.current.set(n.id, { ...n.position });
+    }
+  }, []);
+
+  const onNodeDragStop: XF.OnNodeDrag = useCallback(
+    (_event, _node, nodes) => {
+      const moved = nodes
+        .filter((n) => dragStartPositions.current.has(n.id))
+        .map((n) => ({
+          from: dragStartPositions.current.get(n.id)!,
+          id: n.id,
+          to: { ...n.position },
+        }))
+        .filter((n) => n.from.x !== n.to.x || n.from.y !== n.to.y);
+      dragStartPositions.current.clear();
+      if (moved.length > 0) undoStack?.push({ nodes: moved, type: 'position' });
+    },
+    [undoStack],
+  );
+
   const onChange: XF.OnNodesChange = (_) => {
     const changes = Array.groupBy(_, (_) => _.type) as { [T in XF.NodeChange as T['type']]?: T[] };
 
@@ -131,19 +161,44 @@ export const useNodesState = () => {
     changes.position?.forEach(handlePositionChange);
 
     if (changes.remove?.length) {
-      pipe(
-        changes.remove.map((_) => nodeServerCollection.utils.getKeyObject({ nodeId: Ulid.fromCanonical(_.id).bytes })),
-        nodeServerCollection.utils.delete,
-      );
-
-      pipe(
-        changes.remove.map((_) => _.id),
-        nodeClientCollection.delete,
+      const nodeIds = changes.remove.map((_) => Ulid.fromCanonical(_.id).bytes);
+      const removeKeys = changes.remove.map((_) =>
+        nodeServerCollection.utils.getKeyObject({ nodeId: Ulid.fromCanonical(_.id).bytes }),
       );
+      const clientKeys = changes.remove.map((_) => _.id);
+
+      // Copy YAML before deleting so undo has the full node data.
+      // Delete must wait for copy to avoid a race condition with the server.
+      void (async () => {
+        try {
+          const res = await request({
+            input: { flowId, nodeIds },
+            method: FlowService.method.flowNodesCopy,
+            transport,
+          });
+          undoStack?.push({ flowId, type: 'node-delete', yaml: res.message.yaml });
+        } catch {
+          // If copy fails, delete proceeds without undo support
+        }
+
+        // Delete edges connected to removed nodes before deleting the nodes
+        const nodeIdSet = new Set(changes.remove!.map((_) => _.id));
+        const connectedEdgeKeys = [...edgeServerCollection.values()]
+          .filter(
+            (e) =>
+              nodeIdSet.has(Ulid.construct(e.sourceId).toCanonical()) ||
+              nodeIdSet.has(Ulid.construct(e.targetId).toCanonical()),
+          )
+          .map((e) => edgeServerCollection.utils.getKeyObject({ edgeId: e.edgeId }));
+        if (connectedEdgeKeys.length > 0) edgeServerCollection.utils.delete(connectedEdgeKeys);
+
+        pipe(removeKeys, nodeServerCollection.utils.delete);
+        pipe(clientKeys, nodeClientCollection.delete);
+      })();
     }
   };
 
-  return { nodes: items, onNodesChange: onChange };
+  return { handlePositionChange, nodes: items, onNodeDragStart, onNodeDragStop, onNodesChange: onChange };
 };
 
 const nodeBodyStyles = tv({
diff --git a/packages/client/src/pages/flow/nodes/http.tsx b/packages/client/src/pages/flow/nodes/http.tsx
index 4e335b57f..d4b58e523 100644
--- a/packages/client/src/pages/flow/nodes/http.tsx
+++ b/packages/client/src/pages/flow/nodes/http.tsx
@@ -23,6 +23,8 @@ import { FlowContext } from '../context';
 import { Handle } from '../handle';
 import { NodeSettingsBody, NodeSettingsOutputProps, NodeSettingsProps, SimpleNode } from '../node';
 
+const defaultNodeHttp = create(NodeHttpSchema);
+
 export const HttpNode = ({ id, selected }: XF.NodeProps) => {
   const nodeId = Ulid.fromCanonical(id).bytes;
 
@@ -36,7 +38,7 @@ export const HttpNode = ({ id, selected }: XF.NodeProps) => {
           .select((_) => pick(_.item, 'httpId', 'deltaHttpId'))
           .findOne(),
       [nodeHttpCollection, nodeId],
-    ).data ?? create(NodeHttpSchema);
+    ).data ?? defaultNodeHttp;
 
   const deltaOptions = {
     deltaId: deltaHttpId,
@@ -90,7 +92,7 @@ export const HttpSettings = ({ nodeId }: NodeSettingsProps) => {
           .select((_) => pick(_.item, 'httpId', 'deltaHttpId'))
           .findOne(),
       [nodeHttpCollection, nodeId],
-    ).data ?? create(NodeHttpSchema);
+    ).data ?? defaultNodeHttp;
 
   return (
     <NodeSettingsBody
diff --git a/packages/client/src/pages/flow/selection.ts b/packages/client/src/pages/flow/selection.ts
new file mode 100644
index 000000000..58751a9df
--- /dev/null
+++ b/packages/client/src/pages/flow/selection.ts
@@ -0,0 +1,42 @@
+import * as XF from '@xyflow/react';
+import { useCallback } from 'react';
+
+/**
+ * Centralized selection API for flow nodes and edges.
+ *
+ * All selection writes go through ReactFlow's store actions
+ * (`addSelectedNodes`, `unselectNodesAndEdges`, `triggerNodeChanges`)
+ * to keep both `nodeLookup` and client collections in sync.
+ */
+export const useFlowSelection = () => {
+  const storeApi = XF.useStoreApi();
+
+  const selectedNodeIds = XF.useStore(
+    (s) => s.nodes.filter((n) => n.selected).map((n) => n.id),
+    (a, b) => a.length === b.length && a.every((id, i) => id === b[i]),
+  );
+
+  /** Select nodes exclusively — deselects all other nodes and edges first. */
+  const selectNodes = useCallback(
+    (ids: string[]) => {
+      const { addSelectedNodes } = storeApi.getState();
+      addSelectedNodes(ids);
+    },
+    [storeApi],
+  );
+
+  const deselectNodes = useCallback(
+    (ids: string[]) => {
+      const { triggerNodeChanges } = storeApi.getState();
+      triggerNodeChanges(ids.map((id) => ({ id, selected: false, type: 'select' as const })));
+    },
+    [storeApi],
+  );
+
+  const deselectAll = useCallback(() => {
+    const { unselectNodesAndEdges } = storeApi.getState();
+    unselectNodesAndEdges();
+  }, [storeApi]);
+
+  return { deselectAll, deselectNodes, selectedNodeIds, selectNodes };
+};
diff --git a/packages/client/src/pages/flow/undo.ts b/packages/client/src/pages/flow/undo.ts
new file mode 100644
index 000000000..de73196cd
--- /dev/null
+++ b/packages/client/src/pages/flow/undo.ts
@@ -0,0 +1,155 @@
+import { Ulid } from 'id128';
+import { useMemo } from 'react';
+import { HandleKind } from '@the-dev-tools/spec/buf/api/flow/v1/flow_pb';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface EdgeSnapshot {
+  flowId: Uint8Array;
+  sourceHandle: HandleKind;
+  sourceId: Uint8Array;
+  targetId: Uint8Array;
+}
+
+interface PasteOffset {
+  x: number;
+  y: number;
+}
+
+export type UndoEntry =
+  | { edgeIds: Uint8Array[]; edges: EdgeSnapshot[]; type: 'edge-insert' }
+  | { edges: EdgeSnapshot[]; type: 'edge-delete' }
+  | { flowId: Uint8Array; nodeIds: Uint8Array[]; pasteOffset: PasteOffset; type: 'paste'; yaml: string }
+  | { flowId: Uint8Array; pasteOffset?: PasteOffset; type: 'node-delete'; yaml: string }
+  | { nodes: { from: { x: number; y: number }; id: string; to: { x: number; y: number } }[]; type: 'position' };
+
+export interface UndoExecutors {
+  deleteEdges(edgeIds: Uint8Array[]): void;
+  deleteNodes(nodeIds: Uint8Array[]): void;
+  deselectAll(): void;
+  insertEdge(edge: EdgeSnapshot): Uint8Array;
+  pasteNodes(yaml: string, flowId: Uint8Array, offset: PasteOffset): Promise<Uint8Array[]>;
+  updateNodePositions(nodes: { id: string; position: { x: number; y: number } }[]): void;
+}
+
+// ---------------------------------------------------------------------------
+// UndoStack
+// ---------------------------------------------------------------------------
+
+const MAX_STACK_SIZE = 50;
+
+export class UndoStack {
+  private executing = false;
+  private executors: null | UndoExecutors = null;
+  private redoEntries: UndoEntry[] = [];
+  private undoEntries: UndoEntry[] = [];
+
+  setExecutors(executors: UndoExecutors) {
+    this.executors = executors;
+  }
+
+  push(entry: UndoEntry) {
+    if (this.executing) return;
+    this.undoEntries.push(entry);
+    if (this.undoEntries.length > MAX_STACK_SIZE) this.undoEntries.shift();
+    this.redoEntries = [];
+  }
+
+  async undo() {
+    if (this.executing || !this.executors || this.undoEntries.length === 0) return;
+    this.executing = true;
+    try {
+      const entry = this.undoEntries.pop()!;
+      const redoEntry = await this.executeInverse(entry);
+      if (redoEntry) this.redoEntries.push(redoEntry);
+    } finally {
+      this.executing = false;
+    }
+  }
+
+  async redo() {
+    if (this.executing || !this.executors || this.redoEntries.length === 0) return;
+    this.executing = true;
+    try {
+      const entry = this.redoEntries.pop()!;
+      const undoEntry = await this.executeInverse(entry);
+      if (undoEntry) this.undoEntries.push(undoEntry);
+    } finally {
+      this.executing = false;
+    }
+  }
+
+  clear() {
+    this.undoEntries = [];
+    this.redoEntries = [];
+  }
+
+  get canUndo() {
+    return this.undoEntries.length > 0;
+  }
+
+  get canRedo() {
+    return this.redoEntries.length > 0;
+  }
+
+  // Execute the inverse of an entry, returning a new entry for the opposite stack
+  private async executeInverse(entry: UndoEntry): Promise<null | UndoEntry> {
+    const exec = this.executors!;
+    exec.deselectAll();
+
+    switch (entry.type) {
+      case 'edge-delete': {
+        // Undo edge delete = re-insert edges, inverse is edge-insert (to delete them again on redo)
+        const newEdgeIds = entry.edges.map((_) => exec.insertEdge(_));
+        return { edgeIds: newEdgeIds, edges: entry.edges, type: 'edge-insert' };
+      }
+
+      case 'edge-insert': {
+        // Undo edge insert = delete the inserted edges, inverse is edge-delete (to re-insert on redo)
+        exec.deleteEdges(entry.edgeIds);
+        return { edges: entry.edges, type: 'edge-delete' };
+      }
+
+      case 'node-delete': {
+        // Undo delete = paste the YAML back
+        const pasteOffset = entry.pasteOffset ?? { x: 0, y: 0 };
+        const newNodeIds = await exec.pasteNodes(entry.yaml, entry.flowId, pasteOffset);
+        return { flowId: entry.flowId, nodeIds: newNodeIds, pasteOffset, type: 'paste', yaml: entry.yaml };
+      }
+
+      case 'paste': {
+        // Undo paste = delete pasted nodes
+        exec.deleteNodes(entry.nodeIds);
+        return { flowId: entry.flowId, pasteOffset: entry.pasteOffset, type: 'node-delete', yaml: entry.yaml };
+      }
+
+      case 'position': {
+        exec.updateNodePositions(entry.nodes.map((_) => ({ id: _.id, position: _.from })));
+        return {
+          nodes: entry.nodes.map((_) => ({ from: _.to, id: _.id, to: _.from })),
+          type: 'position',
+        };
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+
+const stacks = new Map<string, UndoStack>();
+
+export const useUndoStack = (flowId: Uint8Array): UndoStack => {
+  const key = Ulid.construct(flowId).toCanonical();
+  return useMemo(() => {
+    let stack = stacks.get(key);
+    if (!stack) {
+      stack = new UndoStack();
+      stacks.set(key, stack);
+    }
+    return stack;
+  }, [key]);
+};
diff --git a/packages/db/pkg/sqlc/gen/db.go b/packages/db/pkg/sqlc/gen/db.go
index e04f5d8e0..d50582dd1 100644
--- a/packages/db/pkg/sqlc/gen/db.go
+++ b/packages/db/pkg/sqlc/gen/db.go
@@ -477,6 +477,12 @@ func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
 	if q.getFlowEdgesByFlowIDsStmt, err = db.PrepareContext(ctx, getFlowEdgesByFlowIDs); err != nil {
 		return nil, fmt.Errorf("error preparing query GetFlowEdgesByFlowIDs: %w", err)
 	}
+	if q.getFlowEdgesBySourceNodeIDsStmt, err = db.PrepareContext(ctx, getFlowEdgesBySourceNodeIDs); err != nil {
+		return nil, fmt.Errorf("error preparing query GetFlowEdgesBySourceNodeIDs: %w", err)
+	}
+	if q.getFlowEdgesByTargetNodeIDsStmt, err = db.PrepareContext(ctx, getFlowEdgesByTargetNodeIDs); err != nil {
+		return nil, fmt.Errorf("error preparing query GetFlowEdgesByTargetNodeIDs: %w", err)
+	}
 	if q.getFlowNodeStmt, err = db.PrepareContext(ctx, getFlowNode); err != nil {
 		return nil, fmt.Errorf("error preparing query GetFlowNode: %w", err)
 	}
@@ -1705,6 +1711,16 @@ func (q *Queries) Close() error {
 			err = fmt.Errorf("error closing getFlowEdgesByFlowIDsStmt: %w", cerr)
 		}
 	}
+	if q.getFlowEdgesBySourceNodeIDsStmt != nil {
+		if cerr := q.getFlowEdgesBySourceNodeIDsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getFlowEdgesBySourceNodeIDsStmt: %w", cerr)
+		}
+	}
+	if q.getFlowEdgesByTargetNodeIDsStmt != nil {
+		if cerr := q.getFlowEdgesByTargetNodeIDsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getFlowEdgesByTargetNodeIDsStmt: %w", cerr)
+		}
+	}
 	if q.getFlowNodeStmt != nil {
 		if cerr := q.getFlowNodeStmt.Close(); cerr != nil {
 			err = fmt.Errorf("error closing getFlowNodeStmt: %w", cerr)
@@ -2675,6 +2691,8 @@ type Queries struct {
 	getFlowEdgeStmt                            *sql.Stmt
 	getFlowEdgesByFlowIDStmt                   *sql.Stmt
 	getFlowEdgesByFlowIDsStmt                  *sql.Stmt
+	getFlowEdgesBySourceNodeIDsStmt            *sql.Stmt
+	getFlowEdgesByTargetNodeIDsStmt            *sql.Stmt
 	getFlowNodeStmt                            *sql.Stmt
 	getFlowNodeAIStmt                          *sql.Stmt
 	getFlowNodeAiProviderStmt                  *sql.Stmt
@@ -2988,6 +3006,8 @@ func (q *Queries) WithTx(tx *sql.Tx) *Queries {
 		getFlowEdgeStmt:                            q.getFlowEdgeStmt,
 		getFlowEdgesByFlowIDStmt:                   q.getFlowEdgesByFlowIDStmt,
 		getFlowEdgesByFlowIDsStmt:                  q.getFlowEdgesByFlowIDsStmt,
+		getFlowEdgesBySourceNodeIDsStmt:            q.getFlowEdgesBySourceNodeIDsStmt,
+		getFlowEdgesByTargetNodeIDsStmt:            q.getFlowEdgesByTargetNodeIDsStmt,
 		getFlowNodeStmt:                            q.getFlowNodeStmt,
 		getFlowNodeAIStmt:                          q.getFlowNodeAIStmt,
 		getFlowNodeAiProviderStmt:                  q.getFlowNodeAiProviderStmt,
diff --git a/packages/db/pkg/sqlc/gen/flow.sql.go b/packages/db/pkg/sqlc/gen/flow.sql.go
index 46f5500bf..2c673455c 100644
--- a/packages/db/pkg/sqlc/gen/flow.sql.go
+++ b/packages/db/pkg/sqlc/gen/flow.sql.go
@@ -1306,6 +1306,100 @@ func (q *Queries) GetFlowEdgesByFlowIDs(ctx context.Context, flowIds []idwrap.ID
 	return items, nil
 }
 
+const getFlowEdgesBySourceNodeIDs = `-- name: GetFlowEdgesBySourceNodeIDs :many
+SELECT id, flow_id, source_id, target_id, source_handle, state
+FROM flow_edge
+WHERE source_id IN (/*SLICE:nodeIds*/?)
+`
+
+// Fetches all edges where source is one of the given node IDs
+func (q *Queries) GetFlowEdgesBySourceNodeIDs(ctx context.Context, nodeids []idwrap.IDWrap) ([]FlowEdge, error) {
+	query := getFlowEdgesBySourceNodeIDs
+	var queryParams []interface{}
+	if len(nodeids) > 0 {
+		for _, v := range nodeids {
+			queryParams = append(queryParams, v)
+		}
+		query = strings.Replace(query, "/*SLICE:nodeIds*/?", strings.Repeat(",?", len(nodeids))[1:], 1)
+	} else {
+		query = strings.Replace(query, "/*SLICE:nodeIds*/?", "NULL", 1)
+	}
+	rows, err := q.query(ctx, nil, query, queryParams...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []FlowEdge{}
+	for rows.Next() {
+		var i FlowEdge
+		if err := rows.Scan(
+			&i.ID,
+			&i.FlowID,
+			&i.SourceID,
+			&i.TargetID,
+			&i.SourceHandle,
+			&i.State,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getFlowEdgesByTargetNodeIDs = `-- name: GetFlowEdgesByTargetNodeIDs :many
+SELECT id, flow_id, source_id, target_id, source_handle, state
+FROM flow_edge
+WHERE target_id IN (/*SLICE:nodeIds*/?)
+`
+
+// Fetches all edges where target is one of the given node IDs
+func (q *Queries) GetFlowEdgesByTargetNodeIDs(ctx context.Context, nodeids []idwrap.IDWrap) ([]FlowEdge, error) {
+	query := getFlowEdgesByTargetNodeIDs
+	var queryParams []interface{}
+	if len(nodeids) > 0 {
+		for _, v := range nodeids {
+			queryParams = append(queryParams, v)
+		}
+		query = strings.Replace(query, "/*SLICE:nodeIds*/?", strings.Repeat(",?", len(nodeids))[1:], 1)
+	} else {
+		query = strings.Replace(query, "/*SLICE:nodeIds*/?", "NULL", 1)
+	}
+	rows, err := q.query(ctx, nil, query, queryParams...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []FlowEdge{}
+	for rows.Next() {
+		var i FlowEdge
+		if err := rows.Scan(
+			&i.ID,
+			&i.FlowID,
+			&i.SourceID,
+			&i.TargetID,
+			&i.SourceHandle,
+			&i.State,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const getFlowNode = `-- name: GetFlowNode :one
 SELECT
   id,
diff --git a/packages/db/pkg/sqlc/queries/flow.sql b/packages/db/pkg/sqlc/queries/flow.sql
index ec4084910..a20589127 100644
--- a/packages/db/pkg/sqlc/queries/flow.sql
+++ b/packages/db/pkg/sqlc/queries/flow.sql
@@ -295,6 +295,18 @@ SELECT id, flow_id
 FROM flow_edge
 WHERE flow_id IN (sqlc.slice('flow_ids'));
 
+-- name: GetFlowEdgesBySourceNodeIDs :many
+-- Fetches all edges where source is one of the given node IDs
+SELECT id, flow_id, source_id, target_id, source_handle, state
+FROM flow_edge
+WHERE source_id IN (sqlc.slice('nodeIds'));
+
+-- name: GetFlowEdgesByTargetNodeIDs :many
+-- Fetches all edges where target is one of the given node IDs
+SELECT id, flow_id, source_id, target_id, source_handle, state
+FROM flow_edge
+WHERE target_id IN (sqlc.slice('nodeIds'));
+
 -- name: CreateFlowEdge :exec
 INSERT INTO
   flow_edge (id, flow_id, source_id, target_id, source_handle, state)
diff --git a/packages/server/cmd/serverrun/serverrun.go b/packages/server/cmd/serverrun/serverrun.go
index d09da5dcd..c69360329 100644
--- a/packages/server/cmd/serverrun/serverrun.go
+++ b/packages/server/cmd/serverrun/serverrun.go
@@ -463,6 +463,7 @@ func Run() error {
 			Flow:               streamers.Flow,
 			Node:               streamers.Node,
 			Edge:               streamers.Edge,
+			Http:               streamers.Http,
 			Var:                streamers.FlowVariable,
 			Version:            streamers.FlowVersion,
 			For:                streamers.For,
diff --git a/packages/server/internal/api/rflowv2/rflowv2.go b/packages/server/internal/api/rflowv2/rflowv2.go
index e135408c2..34958e2ee 100644
--- a/packages/server/internal/api/rflowv2/rflowv2.go
+++ b/packages/server/internal/api/rflowv2/rflowv2.go
@@ -353,6 +353,7 @@ type FlowServiceV2Streamers struct {
 	AiProvider         eventstream.SyncStreamer[AiProviderTopic, AiProviderEvent]
 	Memory             eventstream.SyncStreamer[MemoryTopic, MemoryEvent]
 	Execution          eventstream.SyncStreamer[ExecutionTopic, ExecutionEvent]
+	Http               eventstream.SyncStreamer[rhttp.HttpTopic, rhttp.HttpEvent]
 	HttpResponse       eventstream.SyncStreamer[rhttp.HttpResponseTopic, rhttp.HttpResponseEvent]
 	HttpResponseHeader eventstream.SyncStreamer[rhttp.HttpResponseHeaderTopic, rhttp.HttpResponseHeaderEvent]
 	HttpResponseAssert eventstream.SyncStreamer[rhttp.HttpResponseAssertTopic, rhttp.HttpResponseAssertEvent]
@@ -435,6 +436,7 @@ type FlowServiceV2RPC struct {
 	aiProviderStream         eventstream.SyncStreamer[AiProviderTopic, AiProviderEvent]
 	memoryStream             eventstream.SyncStreamer[MemoryTopic, MemoryEvent]
 	executionStream          eventstream.SyncStreamer[ExecutionTopic, ExecutionEvent]
+	httpStream               eventstream.SyncStreamer[rhttp.HttpTopic, rhttp.HttpEvent]
 	httpResponseStream       eventstream.SyncStreamer[rhttp.HttpResponseTopic, rhttp.HttpResponseEvent]
 	httpResponseHeaderStream eventstream.SyncStreamer[rhttp.HttpResponseHeaderTopic, rhttp.HttpResponseHeaderEvent]
 	httpResponseAssertStream eventstream.SyncStreamer[rhttp.HttpResponseAssertTopic, rhttp.HttpResponseAssertEvent]
@@ -512,6 +514,7 @@ func New(deps FlowServiceV2Deps) *FlowServiceV2RPC {
 		aiProviderStream:         deps.Streamers.AiProvider,
 		memoryStream:             deps.Streamers.Memory,
 		executionStream:          deps.Streamers.Execution,
+		httpStream:               deps.Streamers.Http,
 		httpResponseStream:       deps.Streamers.HttpResponse,
 		httpResponseHeaderStream: deps.Streamers.HttpResponseHeader,
 		httpResponseAssertStream: deps.Streamers.HttpResponseAssert,
diff --git a/packages/server/internal/api/rflowv2/rflowv2_copy_paste.go b/packages/server/internal/api/rflowv2/rflowv2_copy_paste.go
new file mode 100644
index 000000000..8adf30693
--- /dev/null
+++ b/packages/server/internal/api/rflowv2/rflowv2_copy_paste.go
@@ -0,0 +1,847 @@
+//nolint:revive // exported
+package rflowv2
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"connectrpc.com/connect"
+	"gopkg.in/yaml.v3"
+
+	devtoolsdb "github.com/the-dev-tools/dev-tools/packages/db"
+	"github.com/the-dev-tools/dev-tools/packages/server/internal/api/rhttp"
+	"github.com/the-dev-tools/dev-tools/packages/server/internal/converter"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/idwrap"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/ioworkspace"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/model/menv"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/model/mflow"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/model/mhttp"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/model/mworkspace"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/service/sflow"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/service/shttp"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/translate/yamlflowsimplev2"
+	flowv1 "github.com/the-dev-tools/dev-tools/packages/spec/dist/buf/go/api/flow/v1"
+)
+
+// FlowNodesCopy serializes selected nodes to YAML for clipboard copy.
+func (s *FlowServiceV2RPC) FlowNodesCopy(
+	ctx context.Context,
+	req *connect.Request[flowv1.FlowNodesCopyRequest],
+) (*connect.Response[flowv1.FlowNodesCopyResponse], error) {
+	if len(req.Msg.GetFlowId()) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("flow id is required"))
+	}
+	if len(req.Msg.GetNodeIds()) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("at least one node id is required"))
+	}
+
+	flowID, err := idwrap.NewFromBytes(req.Msg.GetFlowId())
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid flow id: %w", err))
+	}
+
+	if err := s.ensureFlowAccess(ctx, flowID); err != nil {
+		return nil, err
+	}
+
+	sourceFlow, err := s.fsReader.GetFlow(ctx, flowID)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("flow not found: %w", err))
+	}
+
+	// Parse requested node IDs
+	selectedIDs := make(map[idwrap.IDWrap]bool, len(req.Msg.GetNodeIds()))
+	for _, rawID := range req.Msg.GetNodeIds() {
+		nodeID, err := idwrap.NewFromBytes(rawID)
+		if err != nil {
+			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid node id: %w", err))
+		}
+		selectedIDs[nodeID] = true
+	}
+
+	// Fetch all nodes in the flow
+	allNodes, err := s.nsReader.GetNodesByFlowID(ctx, flowID)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err)
+	}
+
+	// Filter to selected nodes, skip ManualStart
+	var selectedNodes []mflow.Node
+	for _, n := range allNodes {
+		if selectedIDs[n.ID] && n.NodeKind != mflow.NODE_KIND_MANUAL_START {
+			selectedNodes = append(selectedNodes, n)
+		}
+	}
+
+	if len(selectedNodes) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("no valid nodes selected (ManualStart nodes are excluded)"))
+	}
+
+	// Build WorkspaceBundle for selected nodes
+	bundle := &ioworkspace.WorkspaceBundle{
+		Workspace: mworkspace.Workspace{Name: "_clipboard"},
+		Flows: []mflow.Flow{{
+			ID:          flowID,
+			WorkspaceID: sourceFlow.WorkspaceID,
+			Name:        "_clipboard",
+		}},
+	}
+
+	selectedNodeIDs := make(map[idwrap.IDWrap]bool, len(selectedNodes))
+	for _, n := range selectedNodes {
+		selectedNodeIDs[n.ID] = true
+		bundle.FlowNodes = append(bundle.FlowNodes, n)
+
+		// Fetch type-specific data
+		switch n.NodeKind {
+		case mflow.NODE_KIND_REQUEST:
+			if d, err := s.nrs.GetNodeRequest(ctx, n.ID); err == nil && d != nil {
+				bundle.FlowRequestNodes = append(bundle.FlowRequestNodes, *d)
+				// Fetch HTTP request and all associated data for the exporter
+				if d.HttpID != nil {
+					if h, err := s.hsReader.Get(ctx, *d.HttpID); err == nil {
+						bundle.HTTPRequests = append(bundle.HTTPRequests, *h)
+						s.populateHTTPBundle(ctx, h.ID, bundle)
+					}
+					// If there's a delta, fetch it too for the exporter's delta resolution
+					if d.DeltaHttpID != nil {
+						if dh, err := s.hsReader.Get(ctx, *d.DeltaHttpID); err == nil {
+							bundle.HTTPRequests = append(bundle.HTTPRequests, *dh)
+							s.populateHTTPBundle(ctx, dh.ID, bundle)
+						}
+					}
+				}
+			}
+		case mflow.NODE_KIND_FOR:
+			if d, err := s.nfs.GetNodeFor(ctx, n.ID); err == nil {
+				bundle.FlowForNodes = append(bundle.FlowForNodes, *d)
+			}
+		case mflow.NODE_KIND_FOR_EACH:
+			if d, err := s.nfes.GetNodeForEach(ctx, n.ID); err == nil {
+				bundle.FlowForEachNodes = append(bundle.FlowForEachNodes, *d)
+			}
+		case mflow.NODE_KIND_CONDITION:
+			if d, err := s.nifs.GetNodeIf(ctx, n.ID); err == nil {
+				bundle.FlowConditionNodes = append(bundle.FlowConditionNodes, *d)
+			}
+		case mflow.NODE_KIND_JS:
+			if d, err := s.njss.GetNodeJS(ctx, n.ID); err == nil {
+				bundle.FlowJSNodes = append(bundle.FlowJSNodes, *d)
+			}
+		case mflow.NODE_KIND_AI:
+			if s.nais != nil {
+				if d, err := s.nais.GetNodeAI(ctx, n.ID); err == nil {
+					bundle.FlowAINodes = append(bundle.FlowAINodes, *d)
+				}
+			}
+		case mflow.NODE_KIND_AI_PROVIDER:
+			if s.naps != nil {
+				if d, err := s.naps.GetNodeAiProvider(ctx, n.ID); err == nil {
+					bundle.FlowAIProviderNodes = append(bundle.FlowAIProviderNodes, *d)
+				}
+			}
+		case mflow.NODE_KIND_AI_MEMORY:
+			if s.nmems != nil {
+				if d, err := s.nmems.GetNodeMemory(ctx, n.ID); err == nil {
+					bundle.FlowAIMemoryNodes = append(bundle.FlowAIMemoryNodes, *d)
+				}
+			}
+		}
+	}
+
+	// Fetch edges — keep only edges where both source and target are in the selected set
+	allEdges, err := s.es.GetEdgesByFlowID(ctx, flowID)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err)
+	}
+	for _, e := range allEdges {
+		if selectedNodeIDs[e.SourceID] && selectedNodeIDs[e.TargetID] {
+			bundle.FlowEdges = append(bundle.FlowEdges, e)
+		}
+	}
+
+	// Serialize to YAML
+	yamlBytes, err := yamlflowsimplev2.MarshalSimplifiedYAML(bundle)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to serialize nodes to YAML: %w", err))
+	}
+
+	return connect.NewResponse(&flowv1.FlowNodesCopyResponse{
+		Yaml: string(yamlBytes),
+	}), nil
+}
+
+// populateHTTPBundle fetches headers, params, body, and assertions for an HTTP request
+// and adds them to the workspace bundle.
+func (s *FlowServiceV2RPC) populateHTTPBundle(ctx context.Context, httpID idwrap.IDWrap, bundle *ioworkspace.WorkspaceBundle) {
+	if headers, err := s.hs.GetHeadersByHttpID(ctx, httpID); err == nil {
+		bundle.HTTPHeaders = append(bundle.HTTPHeaders, headers...)
+	}
+	if params, err := s.hs.GetSearchParamsByHttpID(ctx, httpID); err == nil {
+		bundle.HTTPSearchParams = append(bundle.HTTPSearchParams, params...)
+	}
+	if bodyRaw, err := s.hbr.GetByHttpID(ctx, httpID); err == nil && bodyRaw != nil {
+		bundle.HTTPBodyRaw = append(bundle.HTTPBodyRaw, *bodyRaw)
+	}
+	if bodyForms, err := s.hs.GetBodyFormsByHttpID(ctx, httpID); err == nil {
+		bundle.HTTPBodyForms = append(bundle.HTTPBodyForms, bodyForms...)
+	}
+	if bodyUrl, err := s.hs.GetBodyUrlEncodedByHttpID(ctx, httpID); err == nil {
+		bundle.HTTPBodyUrlencoded = append(bundle.HTTPBodyUrlencoded, bodyUrl...)
+	}
+	if asserts, err := s.hs.GetAssertsByHttpID(ctx, httpID); err == nil {
+		bundle.HTTPAsserts = append(bundle.HTTPAsserts, asserts...)
+	}
+}
+
+// FlowNodesPaste parses YAML from clipboard and creates nodes in the target flow.
+func (s *FlowServiceV2RPC) FlowNodesPaste(
+	ctx context.Context,
+	req *connect.Request[flowv1.FlowNodesPasteRequest],
+) (*connect.Response[flowv1.FlowNodesPasteResponse], error) {
+	if len(req.Msg.GetFlowId()) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("flow id is required"))
+	}
+	if req.Msg.GetYaml() == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("yaml is required"))
+	}
+
+	flowID, err := idwrap.NewFromBytes(req.Msg.GetFlowId())
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid flow id: %w", err))
+	}
+
+	if err := s.ensureFlowAccess(ctx, flowID); err != nil {
+		return nil, err
+	}
+
+	targetFlow, err := s.fsReader.GetFlow(ctx, flowID)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("flow not found: %w", err))
+	}
+
+	if err := s.ensureWorkspaceAccess(ctx, targetFlow.WorkspaceID); err != nil {
+		return nil, err
+	}
+
+	// Parse the YAML
+	opts := yamlflowsimplev2.GetDefaultOptions(targetFlow.WorkspaceID)
+	opts.GenerateFiles = false // Don't create sidebar files for pasted nodes
+
+	parsed, err := yamlflowsimplev2.ConvertSimplifiedYAML([]byte(req.Msg.GetYaml()), opts)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("failed to parse YAML: %w", err))
+	}
+
+	if len(parsed.FlowNodes) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("no nodes found in YAML"))
+	}
+
+	// Get existing node names in target flow for deduplication
+	existingNodes, err := s.nsReader.GetNodesByFlowID(ctx, flowID)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err)
+	}
+	existingNames := make(map[string]bool, len(existingNodes))
+	for _, n := range existingNodes {
+		existingNames[n.Name] = true
+	}
+
+	// For USE_EXISTING reference mode, look up existing HTTP requests by name
+	referenceMode := req.Msg.GetReferenceMode()
+	existingHTTPByName := make(map[string]*idwrap.IDWrap)
+	if referenceMode == flowv1.ReferenceMode_REFERENCE_MODE_USE_EXISTING {
+		existingHTTPs, err := s.hs.GetByWorkspaceID(ctx, targetFlow.WorkspaceID)
+		if err == nil {
+			for _, h := range existingHTTPs {
+				id := h.ID
+				existingHTTPByName[h.Name] = &id
+			}
+		}
+	}
+
+	// Apply offset and deduplicate names
+	offsetX := float64(req.Msg.GetOffsetX())
+	offsetY := float64(req.Msg.GetOffsetY())
+
+	// Filter out ManualStart nodes first
+	filteredNodes := parsed.FlowNodes[:0]
+	for _, n := range parsed.FlowNodes {
+		if n.NodeKind != mflow.NODE_KIND_MANUAL_START {
+			filteredNodes = append(filteredNodes, n)
+		}
+	}
+	parsed.FlowNodes = filteredNodes
+
+	// Build node ID mapping (old parsed ID -> new ID) and name mapping for variable remapping
+	nodeIDMapping := make(map[idwrap.IDWrap]idwrap.IDWrap, len(parsed.FlowNodes))
+	nameMapping := make(map[string]string) // oldName -> newName (only for renamed nodes)
+	for i := range parsed.FlowNodes {
+		oldID := parsed.FlowNodes[i].ID
+		newID := idwrap.NewNow()
+		nodeIDMapping[oldID] = newID
+
+		// Update the node
+		parsed.FlowNodes[i].ID = newID
+		parsed.FlowNodes[i].FlowID = flowID
+		parsed.FlowNodes[i].PositionX += offsetX
+		parsed.FlowNodes[i].PositionY += offsetY
+		parsed.FlowNodes[i].State = mflow.NODE_STATE_UNSPECIFIED
+
+		// Deduplicate names
+		originalName := parsed.FlowNodes[i].Name
+		name := originalName
+		if existingNames[name] {
+			counter := 1
+			for existingNames[fmt.Sprintf("%s_%d", name, counter)] {
+				counter++
+			}
+			name = fmt.Sprintf("%s_%d", name, counter)
+			parsed.FlowNodes[i].Name = name
+		}
+		if name != originalName {
+			nameMapping[originalName] = name
+		}
+		existingNames[name] = true
+	}
+
+	// Remap type-specific node IDs
+	for i := range parsed.FlowRequestNodes {
+		if newID, ok := nodeIDMapping[parsed.FlowRequestNodes[i].FlowNodeID]; ok {
+			parsed.FlowRequestNodes[i].FlowNodeID = newID
+		}
+	}
+	for i := range parsed.FlowConditionNodes {
+		if newID, ok := nodeIDMapping[parsed.FlowConditionNodes[i].FlowNodeID]; ok {
+			parsed.FlowConditionNodes[i].FlowNodeID = newID
+		}
+	}
+	for i := range parsed.FlowForNodes {
+		if newID, ok := nodeIDMapping[parsed.FlowForNodes[i].FlowNodeID]; ok {
+			parsed.FlowForNodes[i].FlowNodeID = newID
+		}
+	}
+	for i := range parsed.FlowForEachNodes {
+		if newID, ok := nodeIDMapping[parsed.FlowForEachNodes[i].FlowNodeID]; ok {
+			parsed.FlowForEachNodes[i].FlowNodeID = newID
+		}
+	}
+	for i := range parsed.FlowJSNodes {
+		if newID, ok := nodeIDMapping[parsed.FlowJSNodes[i].FlowNodeID]; ok {
+			parsed.FlowJSNodes[i].FlowNodeID = newID
+		}
+	}
+	for i := range parsed.FlowAINodes {
+		if newID, ok := nodeIDMapping[parsed.FlowAINodes[i].FlowNodeID]; ok {
+			parsed.FlowAINodes[i].FlowNodeID = newID
+		}
+	}
+	for i := range parsed.FlowAIProviderNodes {
+		if newID, ok := nodeIDMapping[parsed.FlowAIProviderNodes[i].FlowNodeID]; ok {
+			parsed.FlowAIProviderNodes[i].FlowNodeID = newID
+		}
+	}
+	for i := range parsed.FlowAIMemoryNodes {
+		if newID, ok := nodeIDMapping[parsed.FlowAIMemoryNodes[i].FlowNodeID]; ok {
+			parsed.FlowAIMemoryNodes[i].FlowNodeID = newID
+		}
+	}
+
+	// Remap variable references in expression fields when node names changed
+	if len(nameMapping) > 0 {
+		for i := range parsed.FlowConditionNodes {
+			parsed.FlowConditionNodes[i].Condition.Comparisons.Expression = remapVarRefs(
+				parsed.FlowConditionNodes[i].Condition.Comparisons.Expression, nameMapping)
+		}
+		for i := range parsed.FlowForNodes {
+			parsed.FlowForNodes[i].Condition.Comparisons.Expression = remapVarRefs(
+				parsed.FlowForNodes[i].Condition.Comparisons.Expression, nameMapping)
+		}
+		for i := range parsed.FlowForEachNodes {
+			parsed.FlowForEachNodes[i].IterExpression = remapVarRefs(
+				parsed.FlowForEachNodes[i].IterExpression, nameMapping)
+			parsed.FlowForEachNodes[i].Condition.Comparisons.Expression = remapVarRefs(
+				parsed.FlowForEachNodes[i].Condition.Comparisons.Expression, nameMapping)
+		}
+		for i := range parsed.FlowJSNodes {
+			parsed.FlowJSNodes[i].Code = remapAllRefsBytes(parsed.FlowJSNodes[i].Code, nameMapping)
+		}
+		for i := range parsed.FlowAINodes {
+			parsed.FlowAINodes[i].Prompt = remapVarRefs(parsed.FlowAINodes[i].Prompt, nameMapping)
+		}
+		for i := range parsed.HTTPRequests {
+			parsed.HTTPRequests[i].Url = remapVarRefs(parsed.HTTPRequests[i].Url, nameMapping)
+		}
+		for i := range parsed.HTTPHeaders {
+			parsed.HTTPHeaders[i].Value = remapVarRefs(parsed.HTTPHeaders[i].Value, nameMapping)
+		}
+		for i := range parsed.HTTPSearchParams {
+			parsed.HTTPSearchParams[i].Value = remapVarRefs(parsed.HTTPSearchParams[i].Value, nameMapping)
+		}
+		for i := range parsed.HTTPBodyRaw {
+			parsed.HTTPBodyRaw[i].RawData = remapVarRefsBytes(parsed.HTTPBodyRaw[i].RawData, nameMapping)
+		}
+		for i := range parsed.HTTPBodyForms {
+			parsed.HTTPBodyForms[i].Value = remapVarRefs(parsed.HTTPBodyForms[i].Value, nameMapping)
+		}
+		for i := range parsed.HTTPBodyUrlencoded {
+			parsed.HTTPBodyUrlencoded[i].Value = remapVarRefs(parsed.HTTPBodyUrlencoded[i].Value, nameMapping)
+		}
+		for i := range parsed.HTTPAsserts {
+			parsed.HTTPAsserts[i].Value = remapVarRefs(parsed.HTTPAsserts[i].Value, nameMapping)
+		}
+	}
+
+	// Remap edges
+	var validEdges []mflow.Edge
+	for _, e := range parsed.FlowEdges {
+		newSourceID, sourceOK := nodeIDMapping[e.SourceID]
+		newTargetID, targetOK := nodeIDMapping[e.TargetID]
+		if sourceOK && targetOK {
+			e.ID = idwrap.NewNow()
+			e.FlowID = flowID
+			e.SourceID = newSourceID
+			e.TargetID = newTargetID
+			validEdges = append(validEdges, e)
+		}
+	}
+
+	// Handle HTTP requests — resolve references based on referenceMode
+	httpIDMapping := make(map[idwrap.IDWrap]idwrap.IDWrap) // parsed HTTP ID -> actual HTTP ID
+	httpIDsToCreate := make(map[idwrap.IDWrap]bool)        // new HTTP IDs that need creation
+	for i := range parsed.HTTPRequests {
+		httpReq := &parsed.HTTPRequests[i]
+		oldID := httpReq.ID
+		if referenceMode == flowv1.ReferenceMode_REFERENCE_MODE_USE_EXISTING {
+			if existingID, ok := existingHTTPByName[httpReq.Name]; ok {
+				httpIDMapping[oldID] = *existingID
+				continue
+			}
+		}
+		// CREATE_COPY or not found: create new HTTP request
+		newHTTPID := idwrap.NewNow()
+		httpIDMapping[oldID] = newHTTPID
+		httpReq.ID = newHTTPID
+		httpReq.WorkspaceID = targetFlow.WorkspaceID
+		httpReq.IsDelta = false
+		httpReq.ParentHttpID = nil
+		httpIDsToCreate[newHTTPID] = true
+	}
+
+	// Update request node HTTP references
+	for i := range parsed.FlowRequestNodes {
+		rn := &parsed.FlowRequestNodes[i]
+		if rn.HttpID != nil {
+			if newID, ok := httpIDMapping[*rn.HttpID]; ok {
+				rn.HttpID = &newID
+			}
+		}
+		// Clear delta reference — paste always uses resolved (base) requests
+		rn.DeltaHttpID = nil
+	}
+
+	// Remap HTTP children's HttpID fields and filter to only those needing creation
+	var headersToCreate []mhttp.HTTPHeader
+	for i := range parsed.HTTPHeaders {
+		h := &parsed.HTTPHeaders[i]
+		if newID, ok := httpIDMapping[h.HttpID]; ok {
+			h.HttpID = newID
+			h.ID = idwrap.NewNow()
+			h.IsDelta = false
+			h.ParentHttpHeaderID = nil
+			if httpIDsToCreate[newID] {
+				headersToCreate = append(headersToCreate, *h)
+			}
+		}
+	}
+	var paramsToCreate []mhttp.HTTPSearchParam
+	for i := range parsed.HTTPSearchParams {
+		p := &parsed.HTTPSearchParams[i]
+		if newID, ok := httpIDMapping[p.HttpID]; ok {
+			p.HttpID = newID
+			p.ID = idwrap.NewNow()
+			p.IsDelta = false
+			p.ParentHttpSearchParamID = nil
+			if httpIDsToCreate[newID] {
+				paramsToCreate = append(paramsToCreate, *p)
+			}
+		}
+	}
+	var bodyFormsToCreate []mhttp.HTTPBodyForm
+	for i := range parsed.HTTPBodyForms {
+		bf := &parsed.HTTPBodyForms[i]
+		if newID, ok := httpIDMapping[bf.HttpID]; ok {
+			bf.HttpID = newID
+			bf.ID = idwrap.NewNow()
+			bf.IsDelta = false
+			bf.ParentHttpBodyFormID = nil
+			if httpIDsToCreate[newID] {
+				bodyFormsToCreate = append(bodyFormsToCreate, *bf)
+			}
+		}
+	}
+	var bodyUrlToCreate []mhttp.HTTPBodyUrlencoded
+	for i := range parsed.HTTPBodyUrlencoded {
+		bu := &parsed.HTTPBodyUrlencoded[i]
+		if newID, ok := httpIDMapping[bu.HttpID]; ok {
+			bu.HttpID = newID
+			bu.ID = idwrap.NewNow()
+			bu.IsDelta = false
+			bu.ParentHttpBodyUrlEncodedID = nil
+			if httpIDsToCreate[newID] {
+				bodyUrlToCreate = append(bodyUrlToCreate, *bu)
+			}
+		}
+	}
+	var bodyRawToCreate []mhttp.HTTPBodyRaw
+	for i := range parsed.HTTPBodyRaw {
+		br := &parsed.HTTPBodyRaw[i]
+		if newID, ok := httpIDMapping[br.HttpID]; ok {
+			br.HttpID = newID
+			br.ID = idwrap.NewNow()
+			br.IsDelta = false
+			br.ParentBodyRawID = nil
+			if httpIDsToCreate[newID] {
+				bodyRawToCreate = append(bodyRawToCreate, *br)
+			}
+		}
+	}
+	var assertsToCreate []mhttp.HTTPAssert
+	for i := range parsed.HTTPAsserts {
+		a := &parsed.HTTPAsserts[i]
+		if newID, ok := httpIDMapping[a.HttpID]; ok {
+			a.HttpID = newID
+			a.ID = idwrap.NewNow()
+			if httpIDsToCreate[newID] {
+				assertsToCreate = append(assertsToCreate, *a)
+			}
+		}
+	}
+
+	// Begin transaction for creating all entities
+	tx, err := s.DB.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err)
+	}
+	defer devtoolsdb.TxnRollback(tx)
+
+	hsWriter := shttp.NewWriter(tx)
+	headerWriter := shttp.NewHeaderWriter(tx)
+	paramWriter := shttp.NewSearchParamWriter(tx)
+	bodyFormWriter := shttp.NewBodyFormWriter(tx)
+	bodyUrlWriter := shttp.NewBodyUrlEncodedWriter(tx)
+	bodyRawWriter := shttp.NewBodyRawWriter(tx)
+	assertWriter := shttp.NewAssertWriter(tx)
+	nsWriter := sflow.NewNodeWriter(tx)
+	nrsWriter := sflow.NewNodeRequestWriter(tx)
+	nfsWriter := sflow.NewNodeForWriter(tx)
+	nfesWriter := sflow.NewNodeForEachWriter(tx)
+	nifsWriter := sflow.NewNodeIfWriter(tx)
+	njssWriter := sflow.NewNodeJsWriter(tx)
+	esWriter := sflow.NewEdgeWriter(tx)
+
+	// Create HTTP requests that need creation (not USE_EXISTING)
+	for i := range parsed.HTTPRequests {
+		if httpIDsToCreate[parsed.HTTPRequests[i].ID] {
+			if err := hsWriter.Create(ctx, &parsed.HTTPRequests[i]); err != nil {
+				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create HTTP request: %w", err))
+			}
+		}
+	}
+
+	// Create HTTP children
+	for i := range headersToCreate {
+		if err := headerWriter.Create(ctx, &headersToCreate[i]); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create HTTP header: %w", err))
+		}
+	}
+	for i := range paramsToCreate {
+		if err := paramWriter.Create(ctx, &paramsToCreate[i]); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create HTTP search param: %w", err))
+		}
+	}
+	for i := range bodyFormsToCreate {
+		if err := bodyFormWriter.Create(ctx, &bodyFormsToCreate[i]); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create HTTP body form: %w", err))
+		}
+	}
+	for i := range bodyUrlToCreate {
+		if err := bodyUrlWriter.Create(ctx, &bodyUrlToCreate[i]); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create HTTP body urlencoded: %w", err))
+		}
+	}
+	for i := range bodyRawToCreate {
+		if _, err := bodyRawWriter.CreateFull(ctx, &bodyRawToCreate[i]); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create HTTP body raw: %w", err))
+		}
+	}
+	for i := range assertsToCreate {
+		if err := assertWriter.Create(ctx, &assertsToCreate[i]); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create HTTP assert: %w", err))
+		}
+	}
+
+	// Create nodes
+	var createdNodeIDs [][]byte
+	for _, n := range parsed.FlowNodes {
+		if err := nsWriter.CreateNode(ctx, n); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create node: %w", err))
+		}
+		createdNodeIDs = append(createdNodeIDs, n.ID.Bytes())
+	}
+
+	// Create type-specific node records
+	for _, rn := range parsed.FlowRequestNodes {
+		if err := nrsWriter.CreateNodeRequest(ctx, rn); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create request node: %w", err))
+		}
+	}
+	for _, ifn := range parsed.FlowConditionNodes {
+		if err := nifsWriter.CreateNodeIf(ctx, ifn); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create condition node: %w", err))
+		}
+	}
+	for _, fn := range parsed.FlowForNodes {
+		if err := nfsWriter.CreateNodeFor(ctx, fn); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create for node: %w", err))
+		}
+	}
+	for _, fen := range parsed.FlowForEachNodes {
+		if err := nfesWriter.CreateNodeForEach(ctx, fen); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create foreach node: %w", err))
+		}
+	}
+	for _, jsn := range parsed.FlowJSNodes {
+		if err := njssWriter.CreateNodeJS(ctx, jsn); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create js node: %w", err))
+		}
+	}
+	if s.nais != nil {
+		for _, ain := range parsed.FlowAINodes {
+			naisWriter := s.nais.TX(tx)
+			if err := naisWriter.CreateNodeAI(ctx, ain); err != nil {
+				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create ai node: %w", err))
+			}
+		}
+	}
+	if s.naps != nil {
+		for _, apn := range parsed.FlowAIProviderNodes {
+			napsWriter := s.naps.TX(tx)
+			if err := napsWriter.CreateNodeAiProvider(ctx, apn); err != nil {
+				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create ai provider node: %w", err))
+			}
+		}
+	}
+	if s.nmems != nil {
+		for _, mn := range parsed.FlowAIMemoryNodes {
+			nmemsWriter := s.nmems.TX(tx)
+			if err := nmemsWriter.CreateNodeMemory(ctx, mn); err != nil {
+				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create memory node: %w", err))
+			}
+		}
+	}
+
+	// Create edges
+	for _, e := range validEdges {
+		if err := esWriter.CreateEdge(ctx, e); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create edge: %w", err))
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to commit: %w", err))
+	}
+
+	// Publish events for sync
+	for _, n := range parsed.FlowNodes {
+		s.nodeStream.Publish(NodeTopic{FlowID: flowID}, NodeEvent{
+			Type:   nodeEventInsert,
+			FlowID: flowID,
+			Node:   serializeNode(n),
+		})
+	}
+	for _, e := range validEdges {
+		s.edgeStream.Publish(EdgeTopic{FlowID: flowID}, EdgeEvent{
+			Type:   edgeEventInsert,
+			FlowID: flowID,
+			Edge:   serializeEdge(e),
+		})
+	}
+
+	// Publish HTTP events for newly created requests so the client's HttpCollectionSchema stays in sync
+	for i := range parsed.HTTPRequests {
+		if httpIDsToCreate[parsed.HTTPRequests[i].ID] {
+			s.httpStream.Publish(rhttp.HttpTopic{WorkspaceID: targetFlow.WorkspaceID}, rhttp.HttpEvent{
+				Type: eventTypeInsert,
+				Http: converter.ToAPIHttp(parsed.HTTPRequests[i]),
+			})
+		}
+	}
+
+	return connect.NewResponse(&flowv1.FlowNodesPasteResponse{
+		NodeIds: createdNodeIDs,
+	}), nil
+}
+
+// remapVarRefs replaces node name references inside {{ }} variable expressions.
+// For example, if nameMapping = {"GetUsers": "GetUsers_1"}, then
+// "{{ GetUsers.response.body }}" becomes "{{ GetUsers_1.response.body }}".
+func remapVarRefs(s string, nameMapping map[string]string) string {
+	if len(nameMapping) == 0 || s == "" {
+		return s
+	}
+
+	var result strings.Builder
+	remaining := s
+
+	for {
+		startIdx := strings.Index(remaining, menv.Prefix)
+		if startIdx == -1 {
+			result.WriteString(remaining)
+			break
+		}
+
+		endIdx := strings.Index(remaining[startIdx:], menv.Suffix)
+		if endIdx == -1 {
+			result.WriteString(remaining)
+			break
+		}
+
+		// Write everything before this {{ block
+		result.WriteString(remaining[:startIdx])
+
+		// Extract the content between {{ and }}
+		innerStart := startIdx + menv.PrefixSize
+		innerEnd := startIdx + endIdx
+		inner := remaining[innerStart:innerEnd]
+
+		// Try to match a node name at the start of the inner content
+		trimmedInner := strings.TrimSpace(inner)
+		replaced := false
+		for oldName, newName := range nameMapping {
+			// Match "oldName.something" or "oldName" exactly
+			if strings.HasPrefix(trimmedInner, oldName) {
+				rest := trimmedInner[len(oldName):]
+				if rest == "" || rest[0] == '.' {
+					// Preserve original whitespace by replacing within the trimmed portion
+					newInner := strings.Replace(inner, oldName, newName, 1)
+					result.WriteString(menv.Prefix)
+					result.WriteString(newInner)
+					result.WriteString(menv.Suffix)
+					replaced = true
+					break
+				}
+			}
+		}
+
+		if !replaced {
+			// Write the original {{ ... }} block unchanged
+			result.WriteString(remaining[startIdx : startIdx+endIdx+menv.SuffixSize])
+		}
+
+		remaining = remaining[startIdx+endIdx+menv.SuffixSize:]
+	}
+
+	return result.String()
+}
+
+// remapVarRefsBytes is a convenience wrapper for []byte fields.
+func remapVarRefsBytes(b []byte, nameMapping map[string]string) []byte {
+	if len(nameMapping) == 0 || len(b) == 0 {
+		return b
+	}
+	return []byte(remapVarRefs(string(b), nameMapping))
+}
+
+// remapJSBracketRefs replaces ["NodeName"] and ['NodeName'] references in JS code.
+// The variable name before the bracket (ctx, context, etc.) doesn't matter —
+// we match the bracket pattern directly since node names are known.
+func remapJSBracketRefs(s string, nameMapping map[string]string) string {
+	if len(nameMapping) == 0 || s == "" {
+		return s
+	}
+	for oldName, newName := range nameMapping {
+		s = strings.ReplaceAll(s, `["`+oldName+`"]`, `["`+newName+`"]`)
+		s = strings.ReplaceAll(s, `['`+oldName+`']`, `['`+newName+`']`)
+	}
+	return s
+}
+
+// remapAllRefs applies both {{ }} variable remapping and JS ctx[] remapping.
+func remapAllRefs(s string, nameMapping map[string]string) string {
+	s = remapVarRefs(s, nameMapping)
+	s = remapJSBracketRefs(s, nameMapping)
+	return s
+}
+
+// remapAllRefsBytes is a convenience wrapper for []byte fields.
+func remapAllRefsBytes(b []byte, nameMapping map[string]string) []byte {
+	if len(nameMapping) == 0 || len(b) == 0 {
+		return b
+	}
+	return []byte(remapAllRefs(string(b), nameMapping))
+}
+
+// FlowNodesPastePreview checks which HTTP requests from clipboard YAML already exist in the target workspace.
+func (s *FlowServiceV2RPC) FlowNodesPastePreview(
+	ctx context.Context,
+	req *connect.Request[flowv1.FlowNodesPastePreviewRequest],
+) (*connect.Response[flowv1.FlowNodesPastePreviewResponse], error) {
+	if len(req.Msg.GetFlowId()) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("flow id is required"))
+	}
+	if req.Msg.GetYaml() == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("yaml is required"))
+	}
+
+	flowID, err := idwrap.NewFromBytes(req.Msg.GetFlowId())
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid flow id: %w", err))
+	}
+
+	if err := s.ensureFlowAccess(ctx, flowID); err != nil {
+		return nil, err
+	}
+
+	targetFlow, err := s.fsReader.GetFlow(ctx, flowID)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("flow not found: %w", err))
+	}
+
+	// Parse the YAML to extract request names
+	var yamlFormat yamlflowsimplev2.YamlFlowFormatV2
+	if err := yaml.Unmarshal([]byte(req.Msg.GetYaml()), &yamlFormat); err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid YAML: %w", err))
+	}
+
+	// Collect request names from the YAML
+	requestNames := make(map[string]bool)
+	for _, r := range yamlFormat.Requests {
+		if r.Name != "" {
+			requestNames[r.Name] = true
+		}
+	}
+
+	if len(requestNames) == 0 {
+		return connect.NewResponse(&flowv1.FlowNodesPastePreviewResponse{}), nil
+	}
+
+	// Check which exist in the target workspace
+	existingHTTPs, err := s.hs.GetByWorkspaceID(ctx, targetFlow.WorkspaceID)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err)
+	}
+
+	var existingRequests []string
+	for _, h := range existingHTTPs {
+		if requestNames[h.Name] {
+			existingRequests = append(existingRequests, h.Name)
+		}
+	}
+
+	return connect.NewResponse(&flowv1.FlowNodesPastePreviewResponse{
+		ExistingRequests: existingRequests,
+	}), nil
+}
diff --git a/packages/server/internal/api/rflowv2/rflowv2_copy_paste_test.go b/packages/server/internal/api/rflowv2/rflowv2_copy_paste_test.go
new file mode 100644
index 000000000..24a54249f
--- /dev/null
+++ b/packages/server/internal/api/rflowv2/rflowv2_copy_paste_test.go
@@ -0,0 +1,473 @@
+package rflowv2
+
+import (
+	"testing"
+
+	"connectrpc.com/connect"
+	"github.com/stretchr/testify/require"
+
+	"github.com/the-dev-tools/dev-tools/packages/server/internal/api/rhttp"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/eventstream/memory"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/idwrap"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/model/mcondition"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/model/mflow"
+	"github.com/the-dev-tools/dev-tools/packages/server/pkg/service/shttp"
+	flowv1 "github.com/the-dev-tools/dev-tools/packages/spec/dist/buf/go/api/flow/v1"
+)
+
+// initCopyPasteTestContext sets up the event streams and HTTP service needed for paste tests.
+func initCopyPasteTestContext(tc *RFlowTestContext) {
+	tc.Svc.nodeStream = memory.NewInMemorySyncStreamer[NodeTopic, NodeEvent]()
+	tc.Svc.edgeStream = memory.NewInMemorySyncStreamer[EdgeTopic, EdgeEvent]()
+	tc.Svc.httpStream = memory.NewInMemorySyncStreamer[rhttp.HttpTopic, rhttp.HttpEvent]()
+	hs := shttp.New(tc.Queries, tc.Svc.logger)
+	tc.Svc.hs = &hs
+}
+
+func TestRemapVarRefs(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       string
+		nameMapping map[string]string
+		expected    string
+	}{
+		{
+			name:        "empty mapping",
+			input:       "{{ GetUsers.response.body }}",
+			nameMapping: map[string]string{},
+			expected:    "{{ GetUsers.response.body }}",
+		},
+		{
+			name:        "empty string",
+			input:       "",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "",
+		},
+		{
+			name:        "no variables",
+			input:       "plain text without vars",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "plain text without vars",
+		},
+		{
+			name:        "simple remap with path",
+			input:       "{{ GetUsers.response.body }}",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "{{ GetUsers_1.response.body }}",
+		},
+		{
+			name:        "remap with surrounding text",
+			input:       "prefix {{ GetUsers.response.status }} suffix",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "prefix {{ GetUsers_1.response.status }} suffix",
+		},
+		{
+			name:        "multiple variables same name",
+			input:       "{{ GetUsers.response.body.id }} and {{ GetUsers.response.body.name }}",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "{{ GetUsers_1.response.body.id }} and {{ GetUsers_1.response.body.name }}",
+		},
+		{
+			name:        "multiple different names",
+			input:       "{{ GetUsers.response.body }} + {{ CreateUser.response.body }}",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1", "CreateUser": "CreateUser_1"},
+			expected:    "{{ GetUsers_1.response.body }} + {{ CreateUser_1.response.body }}",
+		},
+		{
+			name:        "no match - different name",
+			input:       "{{ OtherNode.response.body }}",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "{{ OtherNode.response.body }}",
+		},
+		{
+			name:        "partial name match should not remap",
+			input:       "{{ GetUsersAll.response.body }}",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "{{ GetUsersAll.response.body }}",
+		},
+		{
+			name:        "variable without path",
+			input:       "{{ GetUsers }}",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "{{ GetUsers_1 }}",
+		},
+		{
+			name:        "whitespace preserved",
+			input:       "{{  GetUsers.response.body  }}",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "{{  GetUsers_1.response.body  }}",
+		},
+		{
+			name:        "nested in JSON body",
+			input:       `{"id": "{{ GetUser.response.body.id }}", "name": "{{ GetUser.response.body.name }}"}`,
+			nameMapping: map[string]string{"GetUser": "GetUser_2"},
+			expected:    `{"id": "{{ GetUser_2.response.body.id }}", "name": "{{ GetUser_2.response.body.name }}"}`,
+		},
+		{
+			name:        "mixed env and node references",
+			input:       "{{ #env:BASE_URL }}/{{ GetUsers.response.body.path }}",
+			nameMapping: map[string]string{"GetUsers": "GetUsers_1"},
+			expected:    "{{ #env:BASE_URL }}/{{ GetUsers_1.response.body.path }}",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := remapVarRefs(tt.input, tt.nameMapping)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestRemapVarRefsBytes(t *testing.T) {
+	nameMapping := map[string]string{"request": "request_1"}
+
+	input := []byte("return {{ request.response.body }};")
+	expected := []byte("return {{ request_1.response.body }};")
+
+	result := remapVarRefsBytes(input, nameMapping)
+	require.Equal(t, expected, result)
+
+	// Empty input
+	result = remapVarRefsBytes(nil, nameMapping)
+	require.Nil(t, result)
+
+	// Empty mapping
+	result = remapVarRefsBytes(input, map[string]string{})
+	require.Equal(t, input, result)
+}
+
+func TestRemapJSBracketRefs(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       string
+		nameMapping map[string]string
+		expected    string
+	}{
+		{
+			name:        "double quoted ctx reference",
+			input:       `const data = ctx["Get_All_Todos"].response.body;`,
+			nameMapping: map[string]string{"Get_All_Todos": "Get_All_Todos_1"},
+			expected:    `const data = ctx["Get_All_Todos_1"].response.body;`,
+		},
+		{
+			name:        "single quoted ctx reference",
+			input:       `const data = ctx['Get_All_Todos'].response.body;`,
+			nameMapping: map[string]string{"Get_All_Todos": "Get_All_Todos_1"},
+			expected:    `const data = ctx['Get_All_Todos_1'].response.body;`,
+		},
+		{
+			name:        "custom variable name",
+			input:       `const data = context["Get_All_Todos"].response.body;`,
+			nameMapping: map[string]string{"Get_All_Todos": "Get_All_Todos_1"},
+			expected:    `const data = context["Get_All_Todos_1"].response.body;`,
+		},
+		{
+			name:        "any variable name works",
+			input:       `const data = myVar["NodeA"].body;`,
+			nameMapping: map[string]string{"NodeA": "NodeA_1"},
+			expected:    `const data = myVar["NodeA_1"].body;`,
+		},
+		{
+			name:        "multiple references",
+			input:       `const a = ctx["NodeA"].body; const b = ctx["NodeB"].body;`,
+			nameMapping: map[string]string{"NodeA": "NodeA_1", "NodeB": "NodeB_1"},
+			expected:    `const a = ctx["NodeA_1"].body; const b = ctx["NodeB_1"].body;`,
+		},
+		{
+			name:        "no match",
+			input:       `const data = ctx["OtherNode"].body;`,
+			nameMapping: map[string]string{"Get_All_Todos": "Get_All_Todos_1"},
+			expected:    `const data = ctx["OtherNode"].body;`,
+		},
+		{
+			name:        "realistic JS function",
+			input:       "export default function(ctx) {\n  const todos = ctx[\"Get_All_Todos\"].response.body;\nreturn todos[0];\n}",
+			nameMapping: map[string]string{"Get_All_Todos": "Get_All_Todos_1"},
+			expected:    "export default function(ctx) {\n  const todos = ctx[\"Get_All_Todos_1\"].response.body;\nreturn todos[0];\n}",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := remapJSBracketRefs(tt.input, tt.nameMapping)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestRemapAllRefs(t *testing.T) {
+	// Both {{ }} and ctx[] should be remapped
+	nameMapping := map[string]string{"GetUsers": "GetUsers_1"}
+	input := `const url = "{{ GetUsers.response.body.url }}"; const data = ctx["GetUsers"].response.body;`
+	expected := `const url = "{{ GetUsers_1.response.body.url }}"; const data = ctx["GetUsers_1"].response.body;`
+	result := remapAllRefs(input, nameMapping)
+	require.Equal(t, expected, result)
+}
+
+func TestFlowNodesCopy_JSNodes(t *testing.T) {
+	tc := NewRFlowTestContext(t)
+	defer tc.Close()
+	initCopyPasteTestContext(tc)
+
+	// Create two JS nodes
+	node1 := mflow.Node{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID,
+		Name: "http_request", NodeKind: mflow.NODE_KIND_JS,
+		PositionX: 100, PositionY: 200,
+	}
+	node2 := mflow.Node{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID,
+		Name: "process_data", NodeKind: mflow.NODE_KIND_JS,
+		PositionX: 100, PositionY: 400,
+	}
+	require.NoError(t, tc.NS.CreateNode(tc.Ctx, node1))
+	require.NoError(t, tc.NS.CreateNode(tc.Ctx, node2))
+	require.NoError(t, tc.NJSS.CreateNodeJS(tc.Ctx, mflow.NodeJS{FlowNodeID: node1.ID, Code: []byte("return 1;")}))
+	require.NoError(t, tc.NJSS.CreateNodeJS(tc.Ctx, mflow.NodeJS{FlowNodeID: node2.ID, Code: []byte("return {{ http_request.response.body }};")}))
+
+	// Create edge between them
+	require.NoError(t, tc.ES.CreateEdge(tc.Ctx, mflow.Edge{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID, SourceID: node1.ID, TargetID: node2.ID,
+	}))
+
+	// Copy both nodes
+	copyResp, err := tc.Svc.FlowNodesCopy(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesCopyRequest{
+		FlowId:  tc.FlowID.Bytes(),
+		NodeIds: [][]byte{node1.ID.Bytes(), node2.ID.Bytes()},
+	}))
+	require.NoError(t, err)
+	require.NotEmpty(t, copyResp.Msg.GetYaml())
+	require.Contains(t, copyResp.Msg.GetYaml(), "http_request")
+	require.Contains(t, copyResp.Msg.GetYaml(), "process_data")
+}
+
+func TestFlowNodesPaste_SameFlow_NameDedup(t *testing.T) {
+	tc := NewRFlowTestContext(t)
+	defer tc.Close()
+	initCopyPasteTestContext(tc)
+
+	// Create a JS node
+	node := mflow.Node{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID,
+		Name: "my_script", NodeKind: mflow.NODE_KIND_JS,
+		PositionX: 100, PositionY: 200,
+	}
+	require.NoError(t, tc.NS.CreateNode(tc.Ctx, node))
+	require.NoError(t, tc.NJSS.CreateNodeJS(tc.Ctx, mflow.NodeJS{FlowNodeID: node.ID, Code: []byte("return 42;")}))
+
+	// Copy
+	copyResp, err := tc.Svc.FlowNodesCopy(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesCopyRequest{
+		FlowId:  tc.FlowID.Bytes(),
+		NodeIds: [][]byte{node.ID.Bytes()},
+	}))
+	require.NoError(t, err)
+
+	// Paste into same flow
+	pasteResp, err := tc.Svc.FlowNodesPaste(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesPasteRequest{
+		FlowId:        tc.FlowID.Bytes(),
+		Yaml:          copyResp.Msg.GetYaml(),
+		OffsetY:        200,
+		ReferenceMode: flowv1.ReferenceMode_REFERENCE_MODE_CREATE_COPY,
+	}))
+	require.NoError(t, err)
+	require.NotEmpty(t, pasteResp.Msg.GetNodeIds())
+
+	// Verify deduplicated name
+	allNodes, err := tc.NS.GetNodesByFlowID(tc.Ctx, tc.FlowID)
+	require.NoError(t, err)
+
+	names := make(map[string]bool)
+	for _, n := range allNodes {
+		names[n.Name] = true
+	}
+	require.True(t, names["my_script"], "original should exist")
+	require.True(t, names["my_script_1"], "pasted should be deduplicated")
+}
+
+func TestFlowNodesPaste_VarRemapping(t *testing.T) {
+	tc := NewRFlowTestContext(t)
+	defer tc.Close()
+	initCopyPasteTestContext(tc)
+
+	// Create two JS nodes where the second references the first
+	node1 := mflow.Node{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID,
+		Name: "fetch_data", NodeKind: mflow.NODE_KIND_JS,
+		PositionX: 100, PositionY: 200,
+	}
+	node2 := mflow.Node{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID,
+		Name: "process", NodeKind: mflow.NODE_KIND_JS,
+		PositionX: 100, PositionY: 400,
+	}
+	require.NoError(t, tc.NS.CreateNode(tc.Ctx, node1))
+	require.NoError(t, tc.NS.CreateNode(tc.Ctx, node2))
+	require.NoError(t, tc.NJSS.CreateNodeJS(tc.Ctx, mflow.NodeJS{FlowNodeID: node1.ID, Code: []byte("return { items: [1,2,3] };")}))
+	require.NoError(t, tc.NJSS.CreateNodeJS(tc.Ctx, mflow.NodeJS{FlowNodeID: node2.ID, Code: []byte("return {{ fetch_data.response.body.items }};")}))
+
+	// Edge
+	require.NoError(t, tc.ES.CreateEdge(tc.Ctx, mflow.Edge{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID, SourceID: node1.ID, TargetID: node2.ID,
+	}))
+
+	// Copy both
+	copyResp, err := tc.Svc.FlowNodesCopy(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesCopyRequest{
+		FlowId:  tc.FlowID.Bytes(),
+		NodeIds: [][]byte{node1.ID.Bytes(), node2.ID.Bytes()},
+	}))
+	require.NoError(t, err)
+
+	// Paste into same flow
+	pasteResp, err := tc.Svc.FlowNodesPaste(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesPasteRequest{
+		FlowId:        tc.FlowID.Bytes(),
+		Yaml:          copyResp.Msg.GetYaml(),
+		OffsetY:        200,
+		ReferenceMode: flowv1.ReferenceMode_REFERENCE_MODE_CREATE_COPY,
+	}))
+	require.NoError(t, err)
+	require.Len(t, pasteResp.Msg.GetNodeIds(), 2)
+
+	// Find the pasted "process_1" node
+	allNodes, err := tc.NS.GetNodesByFlowID(tc.Ctx, tc.FlowID)
+	require.NoError(t, err)
+
+	var pastedProcessNode *mflow.Node
+	for _, n := range allNodes {
+		if n.Name == "process_1" {
+			pastedProcessNode = &n
+			break
+		}
+	}
+	require.NotNil(t, pastedProcessNode, "should find pasted process_1 node")
+
+	// Check JS code was remapped
+	jsData, err := tc.NJSS.GetNodeJS(tc.Ctx, pastedProcessNode.ID)
+	require.NoError(t, err)
+	require.Contains(t, string(jsData.Code), "fetch_data_1",
+		"JS code should reference fetch_data_1 instead of fetch_data")
+}
+
+func TestFlowNodesPaste_CrossFlow(t *testing.T) {
+	tc := NewRFlowTestContext(t)
+	defer tc.Close()
+	initCopyPasteTestContext(tc)
+
+	// Create a node in the first flow
+	node := mflow.Node{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID,
+		Name: "my_node", NodeKind: mflow.NODE_KIND_JS,
+		PositionX: 100, PositionY: 200,
+	}
+	require.NoError(t, tc.NS.CreateNode(tc.Ctx, node))
+	require.NoError(t, tc.NJSS.CreateNodeJS(tc.Ctx, mflow.NodeJS{FlowNodeID: node.ID, Code: []byte("return 1;")}))
+
+	// Copy
+	copyResp, err := tc.Svc.FlowNodesCopy(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesCopyRequest{
+		FlowId:  tc.FlowID.Bytes(),
+		NodeIds: [][]byte{node.ID.Bytes()},
+	}))
+	require.NoError(t, err)
+
+	// Create a second flow
+	flow2ID := idwrap.NewNow()
+	require.NoError(t, tc.FS.CreateFlow(tc.Ctx, mflow.Flow{
+		ID: flow2ID, WorkspaceID: tc.WorkspaceID, Name: "Second Flow",
+	}))
+
+	// Paste into second flow — no name collision
+	pasteResp, err := tc.Svc.FlowNodesPaste(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesPasteRequest{
+		FlowId:        flow2ID.Bytes(),
+		Yaml:          copyResp.Msg.GetYaml(),
+		OffsetX:        50,
+		OffsetY:        50,
+		ReferenceMode: flowv1.ReferenceMode_REFERENCE_MODE_CREATE_COPY,
+	}))
+	require.NoError(t, err)
+	require.Len(t, pasteResp.Msg.GetNodeIds(), 1)
+
+	// Verify node in second flow with original name and offset applied
+	flow2Nodes, err := tc.NS.GetNodesByFlowID(tc.Ctx, flow2ID)
+	require.NoError(t, err)
+
+	var found bool
+	for _, n := range flow2Nodes {
+		if n.Name == "my_node" {
+			found = true
+			break
+		}
+	}
+	require.True(t, found, "pasted node should exist in second flow")
+}
+
+func TestFlowNodesPaste_ConditionVarRemap(t *testing.T) {
+	tc := NewRFlowTestContext(t)
+	defer tc.Close()
+	initCopyPasteTestContext(tc)
+
+	// Create a JS node and a condition node that references it
+	jsNode := mflow.Node{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID,
+		Name: "check_status", NodeKind: mflow.NODE_KIND_JS,
+		PositionX: 100, PositionY: 200,
+	}
+	condNode := mflow.Node{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID,
+		Name: "is_success", NodeKind: mflow.NODE_KIND_CONDITION,
+		PositionX: 100, PositionY: 400,
+	}
+	require.NoError(t, tc.NS.CreateNode(tc.Ctx, jsNode))
+	require.NoError(t, tc.NS.CreateNode(tc.Ctx, condNode))
+
+	require.NoError(t, tc.NJSS.CreateNodeJS(tc.Ctx, mflow.NodeJS{
+		FlowNodeID: jsNode.ID, Code: []byte("return { status: 200 };"),
+	}))
+	require.NoError(t, tc.NIFS.CreateNodeIf(tc.Ctx, mflow.NodeIf{
+		FlowNodeID: condNode.ID,
+		Condition: mcondition.Condition{
+			Comparisons: mcondition.Comparison{
+				Expression: "{{ check_status.response.body.status }} == 200",
+			},
+		},
+	}))
+
+	// Edge
+	require.NoError(t, tc.ES.CreateEdge(tc.Ctx, mflow.Edge{
+		ID: idwrap.NewNow(), FlowID: tc.FlowID, SourceID: jsNode.ID, TargetID: condNode.ID,
+	}))
+
+	// Copy both
+	copyResp, err := tc.Svc.FlowNodesCopy(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesCopyRequest{
+		FlowId:  tc.FlowID.Bytes(),
+		NodeIds: [][]byte{jsNode.ID.Bytes(), condNode.ID.Bytes()},
+	}))
+	require.NoError(t, err)
+
+	// Paste
+	pasteResp, err := tc.Svc.FlowNodesPaste(tc.Ctx, connect.NewRequest(&flowv1.FlowNodesPasteRequest{
+		FlowId:        tc.FlowID.Bytes(),
+		Yaml:          copyResp.Msg.GetYaml(),
+		OffsetY:        200,
+		ReferenceMode: flowv1.ReferenceMode_REFERENCE_MODE_CREATE_COPY,
+	}))
+	require.NoError(t, err)
+	require.Len(t, pasteResp.Msg.GetNodeIds(), 2)
+
+	// Find pasted condition node
+	allNodes, err := tc.NS.GetNodesByFlowID(tc.Ctx, tc.FlowID)
+	require.NoError(t, err)
+
+	var pastedCondNode *mflow.Node
+	for _, n := range allNodes {
+		if n.Name == "is_success_1" {
+			pastedCondNode = &n
+			break
+		}
+	}
+	require.NotNil(t, pastedCondNode)
+
+	condData, err := tc.NIFS.GetNodeIf(tc.Ctx, pastedCondNode.ID)
+	require.NoError(t, err)
+	require.Contains(t, condData.Condition.Comparisons.Expression, "check_status_1",
+		"condition should reference check_status_1")
+}
diff --git a/packages/server/internal/api/rflowv2/rflowv2_exec.go b/packages/server/internal/api/rflowv2/rflowv2_exec.go
index ed9f40521..415e6df0e 100644
--- a/packages/server/internal/api/rflowv2/rflowv2_exec.go
+++ b/packages/server/internal/api/rflowv2/rflowv2_exec.go
@@ -236,10 +236,28 @@ func (s *FlowServiceV2RPC) executeFlow(
 	}()
 
 	sharedHTTPClient := httpclient.New()
-	edgeMap := mflow.NewEdgesMap(edges)
+
+	// Filter out orphaned edges (source or target node missing) to prevent
+	// runner panics when edges reference deleted nodes.
+	nodeIDSet := make(map[idwrap.IDWrap]struct{}, len(nodes))
+	for _, n := range nodes {
+		nodeIDSet[n.ID] = struct{}{}
+	}
+	validEdges := edges[:0:0]
+	for _, e := range edges {
+		if _, srcOK := nodeIDSet[e.SourceID]; !srcOK {
+			continue
+		}
+		if _, tgtOK := nodeIDSet[e.TargetID]; !tgtOK {
+			continue
+		}
+		validEdges = append(validEdges, e)
+	}
+
+	edgeMap := mflow.NewEdgesMap(validEdges)
 	// Build edgesBySource map for O(1) edge lookup by source node ID
-	edgesBySource := make(map[idwrap.IDWrap][]mflow.Edge, len(edges))
-	for _, edge := range edges {
+	edgesBySource := make(map[idwrap.IDWrap][]mflow.Edge, len(validEdges))
+	for _, edge := range validEdges {
 		edgesBySource[edge.SourceID] = append(edgesBySource[edge.SourceID], edge)
 	}
 
diff --git a/packages/server/internal/api/rflowv2/rflowv2_node.go b/packages/server/internal/api/rflowv2/rflowv2_node.go
index 05fdf25c3..f5c3dd913 100644
--- a/packages/server/internal/api/rflowv2/rflowv2_node.go
+++ b/packages/server/internal/api/rflowv2/rflowv2_node.go
@@ -262,6 +262,16 @@ func (s *FlowServiceV2RPC) NodeDelete(
 		return connect.NewResponse(&emptypb.Empty{}), nil
 	}
 
+	// FETCH: Find all edges connected to nodes being deleted (before transaction)
+	nodeIDs := make([]idwrap.IDWrap, len(validatedItems))
+	for i, data := range validatedItems {
+		nodeIDs[i] = data.nodeID
+	}
+	connectedEdges, err := s.flowEdgeReader.GetEdgesByNodeIDs(ctx, nodeIDs)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err)
+	}
+
 	// 2. Begin transaction with mutation context
 	mut := mutation.New(s.DB, mutation.WithPublisher(s.mutationPublisher()))
 	if err := mut.Begin(ctx); err != nil {
@@ -270,6 +280,21 @@ func (s *FlowServiceV2RPC) NodeDelete(
 	defer mut.Rollback()
 
 	// 3. Execute all deletes in transaction
+
+	// Delete connected edges first (cascade)
+	for i := range connectedEdges {
+		mut.Track(mutation.Event{
+			Entity:   mutation.EntityFlowEdge,
+			Op:       mutation.OpDelete,
+			ID:       connectedEdges[i].ID,
+			ParentID: connectedEdges[i].FlowID,
+		})
+		if err := mut.Queries().DeleteFlowEdge(ctx, connectedEdges[i].ID); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, err)
+		}
+	}
+
+	// Delete nodes
 	for _, data := range validatedItems {
 		mut.Track(mutation.Event{
 			Entity:   mutation.EntityFlowNode,
diff --git a/packages/server/pkg/flow/runner/flowlocalrunner/flowlocalrunner.go b/packages/server/pkg/flow/runner/flowlocalrunner/flowlocalrunner.go
index 76056f840..ad658f934 100644
--- a/packages/server/pkg/flow/runner/flowlocalrunner/flowlocalrunner.go
+++ b/packages/server/pkg/flow/runner/flowlocalrunner/flowlocalrunner.go
@@ -692,16 +692,19 @@ func runNodesMultiNoTimeout(ctx context.Context, startNodeID idwrap.IDWrap, req
 
 		subqueue := queue[:processCount]
 
-		wg.Add(processCount)
 		FlowNodeCancelCtx, FlowNodeCancelCtxCancel := context.WithCancel(ctx)
 		defer FlowNodeCancelCtxCancel()
+		var batchErr error
 		for _, flowNodeID := range subqueue {
 			currentNode, ok := req.NodeMap[flowNodeID]
 			if !ok {
-				return fmt.Errorf("node not found: %v", currentNode)
+				batchErr = fmt.Errorf("node not found: %v", flowNodeID)
+				FlowNodeCancelCtxCancel()
+				break
 			}
 			nodeStateMap[flowNodeID] = FlowNodeStatusLocal{StartTime: time.Now()}
 			seenNodes.Store(flowNodeID, struct{}{})
+			wg.Add(1)
 			go func(nodeID idwrap.IDWrap) {
 				defer wg.Done()
 
@@ -784,6 +787,13 @@ func runNodesMultiNoTimeout(ctx context.Context, startNodeID idwrap.IDWrap, req
 
 		close(resultChan)
 
+		if batchErr != nil {
+			// Drain any results from goroutines that ran before the error
+			for range resultChan {
+			}
+			return batchErr
+		}
+
 		var lastNodeError error
 		for result := range resultChan {
 			status.NodeID = result.originalID
@@ -982,20 +992,22 @@ func runNodesMultiWithTimeout(ctx context.Context, startNodeID idwrap.IDWrap, re
 		timeStart := make(map[idwrap.IDWrap]time.Time, processCount)
 
 		batch := queue[:processCount]
-		wg.Add(processCount)
 		flowCtx, flowCancel := context.WithCancel(ctx)
 		defer flowCancel()
 
+		var batchErr error
 		for _, nodeID := range batch {
 			currentNode, ok := req.NodeMap[nodeID]
 			if !ok {
+				batchErr = fmt.Errorf("node not found: %v", nodeID)
 				flowCancel()
-				return fmt.Errorf("node not found: %v", nodeID)
+				break
 			}
 
 			timeStart[nodeID] = time.Now()
 			seenNodes.Store(nodeID, struct{}{})
 
+			wg.Add(1)
 			go func(nodeID idwrap.IDWrap, flowNode node.FlowNode) {
 				defer wg.Done()
 
@@ -1081,6 +1093,12 @@ func runNodesMultiWithTimeout(ctx context.Context, startNodeID idwrap.IDWrap, re
 		wg.Wait()
 		close(resultChan)
 
+		if batchErr != nil {
+			for range resultChan {
+			}
+			return batchErr
+		}
+
 		queue = queue[processCount:]
 
 		var lastNodeError error
diff --git a/packages/server/pkg/service/sflow/edge_reader.go b/packages/server/pkg/service/sflow/edge_reader.go
index 240506388..cfa646aa1 100644
--- a/packages/server/pkg/service/sflow/edge_reader.go
+++ b/packages/server/pkg/service/sflow/edge_reader.go
@@ -36,3 +36,30 @@ func (r *EdgeReader) GetEdgesByFlowID(ctx context.Context, flowID idwrap.IDWrap)
 	}
 	return tgeneric.MassConvertPtr(edge, ConvertToModelEdge), nil
 }
+
+func (r *EdgeReader) GetEdgesByNodeIDs(ctx context.Context, nodeIDs []idwrap.IDWrap) ([]mflow.Edge, error) {
+	sourceEdges, err := r.queries.GetFlowEdgesBySourceNodeIDs(ctx, nodeIDs)
+	if err != nil {
+		return nil, err
+	}
+	targetEdges, err := r.queries.GetFlowEdgesByTargetNodeIDs(ctx, nodeIDs)
+	if err != nil {
+		return nil, err
+	}
+
+	// Deduplicate: an edge may appear in both results if both source and target are in nodeIDs
+	seen := make(map[idwrap.IDWrap]struct{}, len(sourceEdges))
+	result := make([]mflow.Edge, 0, len(sourceEdges)+len(targetEdges))
+	for i := range sourceEdges {
+		edge := ConvertToModelEdge(sourceEdges[i])
+		seen[edge.ID] = struct{}{}
+		result = append(result, *edge)
+	}
+	for i := range targetEdges {
+		edge := ConvertToModelEdge(targetEdges[i])
+		if _, ok := seen[edge.ID]; !ok {
+			result = append(result, *edge)
+		}
+	}
+	return result, nil
+}
diff --git a/packages/server/pkg/translate/yamlflowsimplev2/converter_node.go b/packages/server/pkg/translate/yamlflowsimplev2/converter_node.go
index 3365000e3..31057b089 100644
--- a/packages/server/pkg/translate/yamlflowsimplev2/converter_node.go
+++ b/packages/server/pkg/translate/yamlflowsimplev2/converter_node.go
@@ -15,6 +15,32 @@ import (
 	"github.com/the-dev-tools/dev-tools/packages/server/pkg/varsystem"
 )
 
+// getStepCommon extracts the YamlStepCommon from any step wrapper
+func getStepCommon(sw YamlStepWrapper) *YamlStepCommon {
+	switch {
+	case sw.Request != nil:
+		return &sw.Request.YamlStepCommon
+	case sw.If != nil:
+		return &sw.If.YamlStepCommon
+	case sw.For != nil:
+		return &sw.For.YamlStepCommon
+	case sw.ForEach != nil:
+		return &sw.ForEach.YamlStepCommon
+	case sw.JS != nil:
+		return &sw.JS.YamlStepCommon
+	case sw.AI != nil:
+		return &sw.AI.YamlStepCommon
+	case sw.AIProvider != nil:
+		return &sw.AIProvider.YamlStepCommon
+	case sw.AIMemory != nil:
+		return &sw.AIMemory.YamlStepCommon
+	case sw.ManualStart != nil:
+		return sw.ManualStart
+	default:
+		return nil
+	}
+}
+
 // createStartNodeWithID creates a default start node with a specific ID
 func createStartNodeWithID(nodeID, flowID idwrap.IDWrap, result *ioworkspace.WorkspaceBundle) {
 	startNode := mflow.Node{
@@ -156,6 +182,20 @@ func processSteps(flowEntry YamlFlowFlowV2, templates map[string]YamlRequestDefV
 			continue
 		}
 
+		// Apply position from YAML if provided
+		common := getStepCommon(stepWrapper)
+		if common != nil && (common.PositionX != nil || common.PositionY != nil) {
+			if len(result.FlowNodes) > 0 {
+				lastIdx := len(result.FlowNodes) - 1
+				if common.PositionX != nil {
+					result.FlowNodes[lastIdx].PositionX = *common.PositionX
+				}
+				if common.PositionY != nil {
+					result.FlowNodes[lastIdx].PositionY = *common.PositionY
+				}
+			}
+		}
+
 		nodeInfoMap[nodeName] = info
 		nodeList = append(nodeList, info)
 	}
diff --git a/packages/server/pkg/translate/yamlflowsimplev2/exporter.go b/packages/server/pkg/translate/yamlflowsimplev2/exporter.go
index 2aa180d18..06f7c01ad 100644
--- a/packages/server/pkg/translate/yamlflowsimplev2/exporter.go
+++ b/packages/server/pkg/translate/yamlflowsimplev2/exporter.go
@@ -3,6 +3,7 @@ package yamlflowsimplev2
 
 import (
 	"fmt"
+	"math"
 	"sort"
 
 	"github.com/the-dev-tools/dev-tools/packages/server/pkg/flowgraph"
@@ -292,10 +293,14 @@ func MarshalSimplifiedYAML(data *ioworkspace.WorkspaceBundle) ([]byte, error) {
 			}
 			sort.Strings(explicitDeps)
 
-			// Common struct logic
+			// Common struct logic — round positions to 2 decimal places
+			posX := math.Round(node.PositionX*100) / 100
+			posY := math.Round(node.PositionY*100) / 100
 			common := YamlStepCommon{
 				Name:      node.Name,
 				DependsOn: StringOrSlice(explicitDeps),
+				PositionX: &posX,
+				PositionY: &posY,
 			}
 
 			switch node.NodeKind {
diff --git a/packages/server/pkg/translate/yamlflowsimplev2/types.go b/packages/server/pkg/translate/yamlflowsimplev2/types.go
index 26e88308a..1caf5ab20 100644
--- a/packages/server/pkg/translate/yamlflowsimplev2/types.go
+++ b/packages/server/pkg/translate/yamlflowsimplev2/types.go
@@ -78,6 +78,8 @@ type YamlStepWrapper struct {
 type YamlStepCommon struct {
 	Name      string        `yaml:"name"`
 	DependsOn StringOrSlice `yaml:"depends_on,omitempty"`
+	PositionX *float64      `yaml:"position_x,omitempty"`
+	PositionY *float64      `yaml:"position_y,omitempty"`
 }
 
 type YamlStepRequest struct {
diff --git a/packages/spec/api/flow.tsp b/packages/spec/api/flow.tsp
index f2049de4a..e905fda41 100644
--- a/packages/spec/api/flow.tsp
+++ b/packages/spec/api/flow.tsp
@@ -276,6 +276,48 @@ model NodeAiMemory {
   windowSize: int32;
 }
 
+// Copy/Paste operations
+enum ReferenceMode {
+  CreateCopy,
+  UseExisting,
+}
+
+model FlowNodesCopyRequest {
+  flowId: Id;
+  nodeIds: Id[];
+}
+
+model FlowNodesCopyResponse {
+  yaml: string;
+}
+
+op FlowNodesCopy(...FlowNodesCopyRequest): FlowNodesCopyResponse;
+
+model FlowNodesPasteRequest {
+  flowId: Id;
+  yaml: string;
+  offsetX: float32;
+  offsetY: float32;
+  referenceMode: ReferenceMode;
+}
+
+model FlowNodesPasteResponse {
+  nodeIds: Id[];
+}
+
+op FlowNodesPaste(...FlowNodesPasteRequest): FlowNodesPasteResponse;
+
+model FlowNodesPastePreviewRequest {
+  flowId: Id;
+  yaml: string;
+}
+
+model FlowNodesPastePreviewResponse {
+  existingRequests: string[];
+}
+
+op FlowNodesPastePreview(...FlowNodesPastePreviewRequest): FlowNodesPastePreviewResponse;
+
 @TanStackDB.collection(#{ isReadOnly: true })
 model NodeExecution {
   @primaryKey nodeExecutionId: Id;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4ef904122..b2b16a50a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -126,9 +126,6 @@ catalogs:
     '@octokit/rest':
       specifier: 22.0.1
       version: 22.0.1
-    '@openreplay/tracker':
-      specifier: 17.1.3
-      version: 17.1.3
     '@prettier/plugin-xml':
       specifier: 3.4.2
       version: 3.4.2
@@ -214,8 +211,8 @@ catalogs:
       specifier: 5.1.2
       version: 5.1.2
     '@xyflow/react':
-      specifier: 12.10.0
-      version: 12.10.0
+      specifier: 12.10.1
+      version: 12.10.1
     babel-plugin-react-compiler:
       specifier: 19.1.0-rc.3
       version: 19.1.0-rc.3
@@ -377,12 +374,12 @@ catalogs:
       version: 2.8.2
 
 overrides:
-  '@types/eslint': '-'
   '@codemirror/autocomplete': 6.20.0
   '@codemirror/commands': 6.10.1
   '@codemirror/language': 6.12.1
   '@codemirror/state': 6.5.3
   '@codemirror/view': 6.39.9
+  '@types/eslint': '-'
 
 patchedDependencies:
   '@effect/platform-node-shared':
@@ -708,9 +705,6 @@ importers:
       '@lezer/lr':
         specifier: 'catalog:'
         version: 1.4.7
-      '@openreplay/tracker':
-        specifier: 'catalog:'
-        version: 17.1.3
       '@prettier/plugin-xml':
         specifier: 'catalog:'
         version: 3.4.2(prettier@3.7.4)
@@ -746,7 +740,7 @@ importers:
         version: 4.25.4(@babel/runtime@7.28.4)(@codemirror/autocomplete@6.20.0)(@codemirror/language@6.12.1)(@codemirror/lint@6.9.2)(@codemirror/search@6.5.11)(@codemirror/state@6.5.3)(@codemirror/theme-one-dark@6.1.3)(@codemirror/view@6.39.9)(codemirror@6.0.2)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       '@xyflow/react':
         specifier: 'catalog:'
-        version: 12.10.0(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+        version: 12.10.1(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       effect:
         specifier: 'catalog:'
         version: 3.19.14
@@ -3446,13 +3440,6 @@ packages:
   '@octokit/types@16.0.0':
     resolution: {integrity: sha512-sKq+9r1Mm4efXW1FCk7hFSeJo4QKreL/tTbR0rz/qx/r1Oa2VV83LTA/H/MuCOX7uCIJmQVRKBcbmWoySjAnSg==}
 
-  '@openreplay/network-proxy@1.2.2':
-    resolution: {integrity: sha512-Zr53s6DZvBvHTDyASMKA4G1pGHZtXLDdmWAk6hDKtnzUdRuNW66D+ja2v+x+zbCGBN95iBlOcAxbLlYbwmoMjg==}
-
-  '@openreplay/tracker@17.1.3':
-    resolution: {integrity: sha512-1Nk6B1/t2C9CuXUBMVmVEaL7zGNhsjW3i1TChGgv177SySf2wYb6+EUIcqOWoXUTbzfPg586/5Lp4ehxMZgJXw==}
-    engines: {node: '>=14.0'}
-
   '@oxc-resolver/binding-android-arm-eabi@11.16.2':
     resolution: {integrity: sha512-lVJbvydLQIDZHKUb6Zs9Rq80QVTQ9xdCQE30eC9/cjg4wsMoEOg65QZPymUAIVJotpUAWJD0XYcwE7ugfxx5kQ==}
     cpu: [arm]
@@ -5531,14 +5518,14 @@ packages:
   '@xtuc/long@4.2.2':
     resolution: {integrity: sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==}
 
-  '@xyflow/react@12.10.0':
-    resolution: {integrity: sha512-eOtz3whDMWrB4KWVatIBrKuxECHqip6PfA8fTpaS2RUGVpiEAe+nqDKsLqkViVWxDGreq0lWX71Xth/SPAzXiw==}
+  '@xyflow/react@12.10.1':
+    resolution: {integrity: sha512-5eSWtIK/+rkldOuFbOOz44CRgQRjtS9v5nufk77DV+XBnfCGL9HAQ8PG00o2ZYKqkEU/Ak6wrKC95Tu+2zuK3Q==}
     peerDependencies:
       react: '>=17'
       react-dom: '>=17'
 
-  '@xyflow/system@0.0.74':
-    resolution: {integrity: sha512-7v7B/PkiVrkdZzSbL+inGAo6tkR/WQHHG0/jhSvLQToCsfa8YubOGmBYd1s08tpKpihdHDZFwzQZeR69QSBb4Q==}
+  '@xyflow/system@0.0.75':
+    resolution: {integrity: sha512-iXs+AGFLi8w/VlAoc/iSxk+CxfT6o64Uw/k0CKASOPqjqz6E0rb5jFZgJtXGZCpfQI6OQpu5EnumP5fGxQheaQ==}
 
   '@yarnpkg/lockfile@1.1.0':
     resolution: {integrity: sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ==}
@@ -6923,12 +6910,6 @@ packages:
   error-ex@1.3.4:
     resolution: {integrity: sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==}
 
-  error-stack-parser-es@0.1.5:
-    resolution: {integrity: sha512-xHku1X40RO+fO8yJ8Wh2f2rZWVjqyhb1zgq1yZ8aZRQkv6OOKhKWRUaht3eSCUbAOBaKIgM+ykwFLE+QUxgGeg==}
-
-  error-stack-parser@2.1.4:
-    resolution: {integrity: sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==}
-
   es-abstract@1.24.1:
     resolution: {integrity: sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw==}
     engines: {node: '>= 0.4'}
@@ -7229,9 +7210,6 @@ packages:
     resolution: {integrity: sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==}
     engines: {node: ^12.20 || >= 14.13}
 
-  fflate@0.8.2:
-    resolution: {integrity: sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==}
-
   figures@3.2.0:
     resolution: {integrity: sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==}
     engines: {node: '>=8'}
@@ -10095,9 +10073,6 @@ packages:
   stackback@0.0.2:
     resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
 
-  stackframe@1.3.4:
-    resolution: {integrity: sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw==}
-
   stat-mode@1.0.0:
     resolution: {integrity: sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==}
     engines: {node: '>= 6'}
@@ -10885,9 +10860,6 @@ packages:
     resolution: {integrity: sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==}
     engines: {node: '>= 14'}
 
-  web-vitals@5.1.0:
-    resolution: {integrity: sha512-ArI3kx5jI0atlTtmV0fWU3fjpLmq/nD3Zr1iFFlJLaqa5wLBkUSzINwBPySCX/8jRyjlmy1Volw1kz1g9XE4Jg==}
-
   webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
@@ -14048,16 +14020,6 @@ snapshots:
     dependencies:
       '@octokit/openapi-types': 27.0.0
 
-  '@openreplay/network-proxy@1.2.2': {}
-
-  '@openreplay/tracker@17.1.3':
-    dependencies:
-      '@openreplay/network-proxy': 1.2.2
-      error-stack-parser: 2.1.4
-      error-stack-parser-es: 0.1.5
-      fflate: 0.8.2
-      web-vitals: 5.1.0
-
   '@oxc-resolver/binding-android-arm-eabi@11.16.2':
     optional: true
 
@@ -16651,9 +16613,9 @@ snapshots:
 
   '@xtuc/long@4.2.2': {}
 
-  '@xyflow/react@12.10.0(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
+  '@xyflow/react@12.10.1(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
     dependencies:
-      '@xyflow/system': 0.0.74
+      '@xyflow/system': 0.0.75
       classcat: 5.0.5
       react: 19.2.3
       react-dom: 19.2.3(react@19.2.3)
@@ -16662,7 +16624,7 @@ snapshots:
       - '@types/react'
       - immer
 
-  '@xyflow/system@0.0.74':
+  '@xyflow/system@0.0.75':
     dependencies:
       '@types/d3-drag': 3.0.7
       '@types/d3-interpolate': 3.0.4
@@ -18137,12 +18099,6 @@ snapshots:
     dependencies:
       is-arrayish: 0.2.1
 
-  error-stack-parser-es@0.1.5: {}
-
-  error-stack-parser@2.1.4:
-    dependencies:
-      stackframe: 1.3.4
-
   es-abstract@1.24.1:
     dependencies:
       array-buffer-byte-length: 1.0.2
@@ -18634,8 +18590,6 @@ snapshots:
       web-streams-polyfill: 3.3.3
     optional: true
 
-  fflate@0.8.2: {}
-
   figures@3.2.0:
     dependencies:
       escape-string-regexp: 1.0.5
@@ -22011,8 +21965,6 @@ snapshots:
 
   stackback@0.0.2: {}
 
-  stackframe@1.3.4: {}
-
   stat-mode@1.0.0: {}
 
   statuses@1.5.0: {}
@@ -22906,8 +22858,6 @@ snapshots:
 
   web-streams-polyfill@4.0.0-beta.3: {}
 
-  web-vitals@5.1.0: {}
-
   webidl-conversions@3.0.1: {}
 
   webpack-sources@3.3.3: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index a13a59c19..cb3a6875f 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -49,7 +49,6 @@ catalog:
   '@nx/web': 22.3.3
   '@octokit/auth-action': 6.0.2
   '@octokit/rest': 22.0.1
-  '@openreplay/tracker': 17.1.3
   '@prettier/plugin-xml': 3.4.2
   '@react-aria/collections': 3.0.1
   '@standard-schema/spec': 1.1.0
@@ -78,7 +77,7 @@ catalog:
   '@typespec/prettier-plugin-typespec': 1.7.0
   '@uiw/react-codemirror': 4.25.4
   '@vitejs/plugin-react': 5.1.2
-  '@xyflow/react': 12.10.0
+  '@xyflow/react': 12.10.1
   babel-plugin-react-compiler: 19.1.0-rc.3
   better-auth: 1.4.18
   builder-util-runtime: 9.5.1
@@ -109,11 +108,11 @@ catalog:
   react-error-boundary: 6.0.2
   react-icons: 5.5.0
   react-markdown: 10.1.0
-  remark-gfm: 4.0.1
   react-resizable-panels: 4.3.0
   react-scan: 0.4.3
   react-stately: 3.43.0
   react-timeago: 8.3.0
+  remark-gfm: 4.0.1
   storybook: 10.1.11
   swc-node: 1.0.0
   syncpack: 13.0.4
@@ -158,12 +157,12 @@ onlyBuiltDependencies:
   - utf-8-validate
 
 overrides:
-  '@types/eslint': '-'
   '@codemirror/autocomplete': 6.20.0
   '@codemirror/commands': 6.10.1
   '@codemirror/language': 6.12.1
   '@codemirror/state': 6.5.3
   '@codemirror/view': 6.39.9
+  '@types/eslint': '-'
 
 patchedDependencies:
   '@effect/platform-node-shared': patches/@effect__platform-node-shared.patch