From df561acba6b72c1844b9373a79d30f3d36555e52 Mon Sep 17 00:00:00 2001
From: dev-hari-prasad <webdev.byhari@gmail.com>
Date: Wed, 30 Sep 2026 01:23:58 +0530
Subject: [PATCH 1/2] Allow reopening closed Scratch Pad via tab context menu
 and update docs. #10474

---
 docs/en_US/query_tool.rst                     |   4 +-
 .../static/js/helpers/Layout/index.jsx        | 122 +++++++--
 .../sqleditor/ScratchPadReopen.spec.js        | 244 ++++++++++++++++++
 3 files changed, 350 insertions(+), 20 deletions(-)
 create mode 100644 web/regression/javascript/sqleditor/ScratchPadReopen.spec.js

diff --git a/docs/en_US/query_tool.rst b/docs/en_US/query_tool.rst
index 8cfdef4150c..62339857645 100644
--- a/docs/en_US/query_tool.rst
+++ b/docs/en_US/query_tool.rst
@@ -35,8 +35,8 @@ The Query Tool features two panels:
   to view the queries that have been executed in the session, a *Scratch Pad*
   which can be used to hold text snippets during editing, and an *AI Assistant*
   tab for generating SQL from natural language (when AI is configured). If the Scratch Pad is
-  closed, it can be re-opened (or additional ones opened) by right-clicking in
-  the SQL Editor and other panels and adding a new panel.
+  closed, it can be re-opened by right-clicking on any panel tab and selecting
+  *Add Panel*.
 * The lower panel displays the *Data Output* panel. The tabbed panel displays
   the result set returned by a query, information about a query's execution plan,
   server messages related to the query's execution and any asynchronous
diff --git a/web/pgadmin/static/js/helpers/Layout/index.jsx b/web/pgadmin/static/js/helpers/Layout/index.jsx
index 2a4f0da0fc1..4d992b9ab3a 100644
--- a/web/pgadmin/static/js/helpers/Layout/index.jsx
+++ b/web/pgadmin/static/js/helpers/Layout/index.jsx
@@ -399,6 +399,51 @@ export class LayoutDocker {
     return siblingIds.find(id => id !== tabId && currentIds.includes(id));
   }
 
+  findDefaultDockPosition(tabId, flatDefault, flatCurrent) {
+    // 1. Try finding a sibling tab in the same panel group
+    const siblingId = this.findSiblingTab(tabId, flatDefault, flatCurrent);
+    if (siblingId) {
+      return { refTabId: siblingId, direction: 'middle' };
+    }
+
+    const currentIds = flatCurrent.map(t => t.id);
+
+    // 2. Try finding an adjacent panel in the same parent box (e.g. Scratch Pad next to Query Editor)
+    const findAdjacentInBox = (box) => {
+      if (!box?.children) return null;
+      for (let i = 0; i < box.children.length; i++) {
+        const child = box.children[i];
+        if (child.tabs && child.tabs.some(t => t.id === tabId)) {
+          // Look for adjacent sibling child in parent box
+          const adjIndices = [i - 1, i + 1].filter(idx => idx >= 0 && idx < box.children.length);
+          for (const adjIdx of adjIndices) {
+            const adjChild = box.children[adjIdx];
+            const adjTabIds = [];
+            const collectIds = (b) => {
+              if (b.tabs) adjTabIds.push(...b.tabs.map(t => t.id));
+              if (b.children) b.children.forEach(collectIds);
+            };
+            collectIds(adjChild);
+            const openAdjTabId = adjTabIds.find(id => currentIds.includes(id));
+            if (openAdjTabId) {
+              const isAfter = i > adjIdx;
+              const direction = box.mode === 'vertical'
+                ? (isAfter ? 'bottom' : 'top')
+                : (isAfter ? 'right' : 'left');
+              return { refTabId: openAdjTabId, direction };
+            }
+          }
+        } else if (child.children) {
+          const res = findAdjacentInBox(child);
+          if (res) return res;
+        }
+      }
+      return null;
+    };
+
+    return findAdjacentInBox(this.defaultLayout?.dockbox);
+  }
+
   saveLayout(l) {
     let api = getApiInstance();
     if(!this.layoutId || !this.layoutObj) {
@@ -576,12 +621,12 @@ export default function Layout({groups, noContextGroups, getLayoutInstance, layo
   const prefStore = usePreferences();
   const dynamicTabsStyleRef = useRef();
   const saveAppStateRef = useRef(prefStore?.getPreferencesForModule('misc')?.save_app_state);
-  const { deleteToolData } = useApplicationState();
+  const { deleteToolData } = useApplicationState() || {};
 
   useEffect(()=>{
     layoutDockerObj.eventBus.registerListener(LAYOUT_EVENTS.REMOVE, (panelId)=>{
       layoutDockerObj.close(panelId);
-      deleteToolData(panelId);
+      deleteToolData?.(panelId);
     });
 
     layoutDockerObj.eventBus.registerListener(LAYOUT_EVENTS.CONTEXT, (e, id, extraMenus)=>{
@@ -613,6 +658,22 @@ export default function Layout({groups, noContextGroups, getLayoutInstance, layo
 
   }, [prefStore]);
 
+  const flatDefaultLayout = useMemo(()=>{
+    const flat = [];
+    const flattenLayout = (box)=>{
+      box.children.forEach((child)=>{
+        if(child.children) {
+          flattenLayout(child);
+        }
+        else {
+          flat.push(...(child.tabs ?? []));
+        }
+      });
+    };
+    flattenLayout(props.defaultLayout.dockbox);
+    return flat;
+  }, [props.defaultLayout]);
+
   const getTabMenuItems = (panelId)=>{
     const ret = [];
     if(panelId) {
@@ -651,6 +712,47 @@ export default function Layout({groups, noContextGroups, getLayoutInstance, layo
           }
         });
       }
+
+      // Check for closed default closable tabs that can be re-opened
+      const missingClosableTabs = flatDefaultLayout.filter(
+        (t) => t.internal?.closable && !layoutDockerObj.isTabOpen(t.id)
+      );
+      if (missingClosableTabs.length > 0) {
+        ret.push({
+          type: 'separator',
+        }, {
+          label: gettext('Add Panel'),
+          getMenuItems: () => missingClosableTabs.map((tab) => ({
+            label: tab.internal?.title || (typeof tab.title === 'string' ? tab.title : tab.id),
+            callback: () => {
+              const flatCurrent = [];
+              const flatten = (box) => {
+                box.children.forEach((child) => {
+                  if (child.children) flatten(child);
+                  else flatCurrent.push(...(child.tabs ?? []));
+                });
+              };
+              const currentDockbox = layoutDockerObj.layoutObj?.getLayout()?.dockbox;
+              if (currentDockbox) {
+                flatten(currentDockbox);
+              }
+              const dockPos = layoutDockerObj.findDefaultDockPosition(tab.id, flatDefaultLayout, flatCurrent);
+              const targetTabId = dockPos?.refTabId || panelId || layoutDockerObj.resetToTabPanel;
+              const targetData = layoutDockerObj.find(targetTabId);
+              const fallbackDirection = targetData?.tabs ? 'middle' : 'after-tab';
+              const direction = dockPos?.direction || fallbackDirection;
+
+              layoutDockerObj.openTab({
+                id: tab.id,
+                content: tab.content,
+                ...tab.internal,
+              }, targetTabId, direction);
+              layoutDockerObj.focus(tab.id);
+              layoutDockerObj.saveLayout();
+            }
+          }))
+        });
+      }
     }
     return ret;
   };
@@ -676,22 +778,6 @@ export default function Layout({groups, noContextGroups, getLayoutInstance, layo
     return savedTab;
   };
 
-  const flatDefaultLayout = useMemo(()=>{
-    const flat = [];
-    const flattenLayout = (box)=>{
-      box.children.forEach((child)=>{
-        if(child.children) {
-          flattenLayout(child);
-        }
-        else {
-          flat.push(...(child.tabs ?? []));
-        }
-      });
-    };
-    flattenLayout(props.defaultLayout.dockbox);
-    return flat;
-  }, [props.defaultLayout]);
-
   const loadTab = (tab)=>{
     const tabData = flatDefaultLayout.find((t)=>t.id == tab.id);
     if(!tabData && tab.metaData) {
diff --git a/web/regression/javascript/sqleditor/ScratchPadReopen.spec.js b/web/regression/javascript/sqleditor/ScratchPadReopen.spec.js
new file mode 100644
index 00000000000..0bf29e1fc06
--- /dev/null
+++ b/web/regression/javascript/sqleditor/ScratchPadReopen.spec.js
@@ -0,0 +1,244 @@
+/////////////////////////////////////////////////////////////
+//
+// pgAdmin 4 - PostgreSQL Tools
+//
+// Copyright (C) 2013 - 2026, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+//////////////////////////////////////////////////////////////
+
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import { withTheme } from '../fake_theme';
+import Layout, { LayoutDocker } from '../../../pgadmin/static/js/helpers/Layout';
+import getApiInstance from '../../../pgadmin/static/js/api_instance';
+import { ApplicationStateProvider } from '../../../pgadmin/settings/static/ApplicationStateProvider';
+
+jest.mock('../../../pgadmin/static/js/api_instance');
+
+describe('ScratchPad Reopen & LayoutDocker dock positioning', () => {
+  const queryToolLayout = {
+    dockbox: {
+      mode: 'vertical',
+      children: [
+        {
+          mode: 'horizontal',
+          children: [
+            {
+              tabs: [
+                LayoutDocker.getPanel({ id: 'id-query', title: 'Query' }),
+                LayoutDocker.getPanel({ id: 'id-history', title: 'Query History' }),
+              ],
+            },
+            {
+              size: 75,
+              tabs: [
+                LayoutDocker.getPanel({
+                  id: 'id-scratch',
+                  title: 'Scratch Pad',
+                  closable: true,
+                  content: <textarea data-testid="scratch-pad-area" />,
+                }),
+              ],
+            },
+          ],
+        },
+        {
+          mode: 'horizontal',
+          children: [
+            {
+              tabs: [
+                LayoutDocker.getPanel({ id: 'id-data-output', title: 'Data Output' }),
+                LayoutDocker.getPanel({ id: 'id-messages', title: 'Messages' }),
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  };
+
+  beforeEach(() => {
+    getApiInstance.mockReturnValue({
+      post: jest.fn().mockResolvedValue({ data: {} }),
+      get: jest.fn().mockResolvedValue({ data: {} }),
+    });
+  });
+
+  describe('findDefaultDockPosition', () => {
+    let layoutDocker;
+
+    beforeEach(() => {
+      layoutDocker = new LayoutDocker('SQLEditor/Layout', queryToolLayout, 'id-messages');
+    });
+
+    it('should find adjacent dock position to the right for Scratch Pad when Query Editor is open', () => {
+      const flatDefault = [
+        { id: 'id-query', title: 'Query' },
+        { id: 'id-history', title: 'Query History' },
+        { id: 'id-scratch', title: 'Scratch Pad', internal: { closable: true } },
+      ];
+      const flatCurrent = [
+        { id: 'id-query', title: 'Query' },
+        { id: 'id-history', title: 'Query History' },
+      ];
+
+      const dockPos = layoutDocker.findDefaultDockPosition('id-scratch', flatDefault, flatCurrent);
+      expect(dockPos).toEqual({
+        refTabId: 'id-query',
+        direction: 'right',
+      });
+    });
+
+    it('should find middle direction for a tab that shares a tab group with an open sibling', () => {
+      const flatDefault = [
+        { id: 'id-query', title: 'Query' },
+        { id: 'id-history', title: 'Query History' },
+        { id: 'id-scratch', title: 'Scratch Pad', internal: { closable: true } },
+      ];
+      const flatCurrent = [
+        { id: 'id-query', title: 'Query' },
+      ];
+
+      const dockPos = layoutDocker.findDefaultDockPosition('id-history', flatDefault, flatCurrent);
+      expect(dockPos).toEqual({
+        refTabId: 'id-query',
+        direction: 'middle',
+      });
+    });
+  });
+
+  describe('Layout Context Menu Add Panel', () => {
+    const ThemedLayout = withTheme(Layout);
+
+    it('should show Add Panel menu when closable tab is closed, and reopen it upon click', async () => {
+      let dockerInstance;
+
+      render(
+        <ApplicationStateProvider>
+          <ThemedLayout
+            defaultLayout={queryToolLayout}
+            layoutId="SQLEditor/Layout"
+            resetToTabPanel="id-messages"
+            getLayoutInstance={(obj) => {
+              dockerInstance = obj;
+            }}
+          />
+        </ApplicationStateProvider>
+      );
+
+      // Verify Scratch Pad tab is initially present
+      expect(screen.queryByText('Scratch Pad')).not.toBeNull();
+
+      // Close Scratch Pad
+      act(() => {
+        dockerInstance.close('id-scratch');
+      });
+
+      expect(dockerInstance.isTabOpen('id-scratch')).toBe(false);
+
+      // Right-click on the Query tab to trigger context menu
+      const queryTabTitle = screen.getByText('Query');
+      fireEvent.contextMenu(queryTabTitle);
+
+      // Context menu should display 'Add Panel'
+      const addPanelMenu = await screen.findByText('Add Panel');
+      expect(addPanelMenu).not.toBeNull();
+
+      // Click or hover on Add Panel to reveal submenu items in react-menu
+      fireEvent.click(addPanelMenu);
+      const scratchSubmenuItem = await screen.findByText('Scratch Pad');
+      expect(scratchSubmenuItem).not.toBeNull();
+
+      // Click on Scratch Pad in the submenu to reopen it
+      act(() => {
+        fireEvent.click(scratchSubmenuItem);
+      });
+
+      // Scratch Pad should now be open again
+      expect(dockerInstance.isTabOpen('id-scratch')).toBe(true);
+    });
+
+    it('should use "after-tab" fallback direction for tab targets when dockPos has no explicit direction', async () => {
+      let dockerInstance;
+
+      render(
+        <ApplicationStateProvider>
+          <ThemedLayout
+            defaultLayout={queryToolLayout}
+            layoutId="SQLEditor/Layout"
+            resetToTabPanel="id-messages"
+            getLayoutInstance={(obj) => {
+              dockerInstance = obj;
+            }}
+          />
+        </ApplicationStateProvider>
+      );
+
+      act(() => {
+        dockerInstance.close('id-scratch');
+      });
+
+      jest.spyOn(dockerInstance, 'findDefaultDockPosition').mockReturnValue(null);
+      const openTabSpy = jest.spyOn(dockerInstance, 'openTab');
+
+      const queryTabTitle = screen.getByText('Query');
+      fireEvent.contextMenu(queryTabTitle);
+
+      const addPanelMenu = await screen.findByText('Add Panel');
+      fireEvent.click(addPanelMenu);
+      const scratchSubmenuItem = await screen.findByText('Scratch Pad');
+
+      act(() => {
+        fireEvent.click(scratchSubmenuItem);
+      });
+
+      expect(openTabSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'id-scratch' }),
+        'id-query',
+        'after-tab'
+      );
+    });
+
+    it('should use "middle" fallback direction when target resolves to a dock panel without explicit dockPos direction', async () => {
+      let dockerInstance;
+
+      render(
+        <ApplicationStateProvider>
+          <ThemedLayout
+            defaultLayout={queryToolLayout}
+            layoutId="SQLEditor/Layout"
+            resetToTabPanel="id-messages"
+            getLayoutInstance={(obj) => {
+              dockerInstance = obj;
+            }}
+          />
+        </ApplicationStateProvider>
+      );
+
+      act(() => {
+        dockerInstance.close('id-scratch');
+      });
+
+      const parentPanel = dockerInstance.find('id-query').parent;
+      jest.spyOn(dockerInstance, 'findDefaultDockPosition').mockReturnValue({ refTabId: parentPanel.id });
+      const openTabSpy = jest.spyOn(dockerInstance, 'openTab');
+
+      const queryTabTitle = screen.getByText('Query');
+      fireEvent.contextMenu(queryTabTitle);
+
+      const addPanelMenu = await screen.findByText('Add Panel');
+      fireEvent.click(addPanelMenu);
+      const scratchSubmenuItem = await screen.findByText('Scratch Pad');
+
+      act(() => {
+        fireEvent.click(scratchSubmenuItem);
+      });
+
+      expect(openTabSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'id-scratch' }),
+        parentPanel.id,
+        'middle'
+      );
+    });
+  });
+});

From 5920f3275e0b67c403222a226cfd3f0d39f683b3 Mon Sep 17 00:00:00 2001
From: Lenovo <mktg@ridhira.com>
Date: Sat, 24 Oct 2026 12:52:34 +0530
Subject: [PATCH 2/2] Reopen closed Scratch Pad via Add Panel in the Query Tool

Dock the panel beside its original neighbour (targeting the panel, not
the tab) and keep the panel's size and maximizable props. Make the Add
Panel menu opt-in via allowAddPanel, set only by the Query Tool. Test the
resulting layout rather than only the computed position.

Fixes #10474

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 docs/en_US/query_tool.rst                     |   3 +-
 .../static/js/helpers/Layout/index.jsx        | 203 ++++++++-------
 .../js/components/QueryToolComponent.jsx      |   1 +
 .../sqleditor/ScratchPadReopen.spec.js        | 231 +++++++-----------
 4 files changed, 197 insertions(+), 241 deletions(-)

diff --git a/docs/en_US/query_tool.rst b/docs/en_US/query_tool.rst
index 62339857645..848dca55546 100644
--- a/docs/en_US/query_tool.rst
+++ b/docs/en_US/query_tool.rst
@@ -36,7 +36,8 @@ The Query Tool features two panels:
   which can be used to hold text snippets during editing, and an *AI Assistant*
   tab for generating SQL from natural language (when AI is configured). If the Scratch Pad is
   closed, it can be re-opened by right-clicking on any panel tab and selecting
-  *Add Panel*.
+  *Add Panel*. Each Query Tool has a single Scratch Pad, so *Add Panel* only lists
+  it while it is closed.
 * The lower panel displays the *Data Output* panel. The tabbed panel displays
   the result set returned by a query, information about a query's execution plan,
   server messages related to the query's execution and any asynchronous
diff --git a/web/pgadmin/static/js/helpers/Layout/index.jsx b/web/pgadmin/static/js/helpers/Layout/index.jsx
index 59b768df55d..a16e42e84f0 100644
--- a/web/pgadmin/static/js/helpers/Layout/index.jsx
+++ b/web/pgadmin/static/js/helpers/Layout/index.jsx
@@ -342,6 +342,8 @@ export class LayoutDocker {
     flattenLayout(this.defaultLayout.dockbox, flatDefault);
     flattenLayout(this.layoutObj.getLayout().dockbox, flatCurrent);
 
+    const currentIds = flatCurrent.map(t => t.id);
+
     // Find tabs in default but not in saved layout
     const missingTabs = _.differenceBy(flatDefault, flatCurrent, 'id');
 
@@ -366,7 +368,7 @@ export class LayoutDocker {
 
     // Add each missing tab next to a sibling from its original panel group
     missingNonClosableTabs.forEach((tab) => {
-      const siblingId = this.findSiblingTab(tab.id, flatDefault, flatCurrent);
+      const siblingId = this.findSiblingTab(tab.id, (id) => currentIds.includes(id));
       if (siblingId) {
         this.openTab({
           id: tab.id,
@@ -389,72 +391,111 @@ export class LayoutDocker {
     });
   }
 
-  findSiblingTab(tabId, flatDefault, flatCurrent) {
-    // Find which panel group this tab belongs to in the default layout
-    const findPanelTabs = (box, targetId) => {
-      for (const child of box.children) {
+  /**
+   * Finds an open tab that shares a panel group with the given tab in the
+   * default layout.
+   * @param {string} tabId - id of the tab to find a sibling for.
+   * @param {function} isOpen - predicate telling whether a tab id is open.
+   * @returns {string|undefined} id of the open sibling, if any.
+   */
+  findSiblingTab(tabId, isOpen) {
+    const siblingIds = this.findDefaultTab(tabId)?.panel.tabs.map(t => t.id);
+    return siblingIds?.find(id => id !== tabId && isOpen(id));
+  }
+
+  /**
+   * Finds a tab in the default layout along with the panel holding it.
+   * @param {string} tabId - id of the tab to look for.
+   * @returns {{tab: object, panel: object}|null}
+   */
+  findDefaultTab(tabId) {
+    const search = (box) => {
+      for (const child of box?.children ?? []) {
         if (child.children) {
-          const result = findPanelTabs(child, targetId);
+          const result = search(child);
           if (result) return result;
-        } else if (child.tabs) {
-          const hasTarget = child.tabs.some(t => t.id === targetId);
-          if (hasTarget) return child.tabs.map(t => t.id);
+        } else {
+          const tab = child.tabs?.find(t => t.id === tabId);
+          if (tab) return {tab, panel: child};
         }
       }
       return null;
     };
-
-    const siblingIds = findPanelTabs(this.defaultLayout.dockbox, tabId);
-    if (!siblingIds) return null;
-
-    // Find a sibling that exists in current layout
-    const currentIds = flatCurrent.map(t => t.id);
-    return siblingIds.find(id => id !== tabId && currentIds.includes(id));
+    return search(this.defaultLayout.dockbox);
   }
 
-  findDefaultDockPosition(tabId, flatDefault, flatCurrent) {
-    // 1. Try finding a sibling tab in the same panel group
-    const siblingId = this.findSiblingTab(tabId, flatDefault, flatCurrent);
+  /**
+   * Works out where a closed default tab should be docked: next to an open
+   * tab of its original panel group, or else beside the neighbouring panel
+   * it sat next to in the default layout.
+   * @param {string} tabId - id of the closed tab.
+   * @returns {{refTabId: string, direction: string}|null} an open tab to dock
+   * against and the rc-dock direction, or null when nothing relevant is open.
+   */
+  findDefaultDockPosition(tabId) {
+    const isOpen = (id) => this.isTabOpen(id);
+    const siblingId = this.findSiblingTab(tabId, isOpen);
     if (siblingId) {
-      return { refTabId: siblingId, direction: 'middle' };
+      return {refTabId: siblingId, direction: 'middle'};
     }
 
-    const currentIds = flatCurrent.map(t => t.id);
-
-    // 2. Try finding an adjacent panel in the same parent box (e.g. Scratch Pad next to Query Editor)
-    const findAdjacentInBox = (box) => {
-      if (!box?.children) return null;
-      for (let i = 0; i < box.children.length; i++) {
-        const child = box.children[i];
-        if (child.tabs && child.tabs.some(t => t.id === tabId)) {
-          // Look for adjacent sibling child in parent box
-          const adjIndices = [i - 1, i + 1].filter(idx => idx >= 0 && idx < box.children.length);
-          for (const adjIdx of adjIndices) {
-            const adjChild = box.children[adjIdx];
-            const adjTabIds = [];
-            const collectIds = (b) => {
-              if (b.tabs) adjTabIds.push(...b.tabs.map(t => t.id));
-              if (b.children) b.children.forEach(collectIds);
-            };
-            collectIds(adjChild);
-            const openAdjTabId = adjTabIds.find(id => currentIds.includes(id));
-            if (openAdjTabId) {
+    const collectIds = (box) => [
+      ...(box.tabs?.map(t => t.id) ?? []),
+      ...(box.children ?? []).flatMap(collectIds),
+    ];
+    const findAdjacent = (box) => {
+      const children = box.children ?? [];
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child.tabs?.some(t => t.id === tabId)) {
+          for (const adjIdx of [i - 1, i + 1]) {
+            const openId = collectIds(children[adjIdx] ?? {}).find(isOpen);
+            if (openId) {
               const isAfter = i > adjIdx;
               const direction = box.mode === 'vertical'
                 ? (isAfter ? 'bottom' : 'top')
                 : (isAfter ? 'right' : 'left');
-              return { refTabId: openAdjTabId, direction };
+              return {refTabId: openId, direction};
             }
           }
         } else if (child.children) {
-          const res = findAdjacentInBox(child);
+          const res = findAdjacent(child);
           if (res) return res;
         }
       }
       return null;
     };
+    return findAdjacent(this.defaultLayout.dockbox);
+  }
 
-    return findAdjacentInBox(this.defaultLayout?.dockbox);
+  /**
+   * Re-opens a closed default tab where it originally was, keeping the size
+   * and other properties of the panel that held it.
+   * @param {string} tabId - id of the default tab to re-open.
+   * @param {string} fallbackTabId - tab whose panel is used when the original
+   * position can't be worked out.
+   */
+  reopenDefaultTab(tabId, fallbackTabId) {
+    const defaultTab = this.findDefaultTab(tabId);
+    if (!defaultTab || this.isTabOpen(tabId)) return;
+
+    const {tab, panel} = defaultTab;
+    const newTab = LayoutDocker.getPanel({id: tab.id, content: tab.content, ...tab.internal});
+    const dockPos = this.findDefaultDockPosition(tabId);
+    const refPanel = this.find(dockPos?.refTabId ?? fallbackTabId)?.parent;
+    if (!refPanel) return;
+
+    // Side directions need a panel target, and can't split a maximised or
+    // floating panel; the other cases join the target's tab group.
+    if (!['left', 'right', 'top', 'bottom'].includes(dockPos?.direction)
+      || ['maximize', 'float'].includes(refPanel.parent?.mode)) {
+      this.layoutObj.dockMove(newTab, refPanel, 'middle');
+    } else {
+      this.layoutObj.dockMove({
+        ..._.pick(panel, ['size', 'minWidth', 'minHeight', 'maxWidth', 'maxHeight', 'maximizable']),
+        tabs: [newTab],
+      }, refPanel, dockPos.direction);
+    }
   }
 
   saveLayout(l) {
@@ -628,7 +669,7 @@ export function getDefaultGroup() {
   };
 }
 
-export default function Layout({groups, noContextGroups, getLayoutInstance, layoutId, savedLayout, resetToTabPanel, enableToolEvents=false, isLayoutVisible=true, className, ...props}) {
+export default function Layout({groups, noContextGroups, getLayoutInstance, layoutId, savedLayout, resetToTabPanel, enableToolEvents=false, isLayoutVisible=true, className, allowAddPanel=false, ...props}) {
   const [[contextPos, contextPanelId, contextExtraMenus], setContextPos] = React.useState([null, null, null]);
   const defaultGroups = React.useMemo(()=>({
     'dialogs': getDialogsGroup(),
@@ -639,12 +680,12 @@ export default function Layout({groups, noContextGroups, getLayoutInstance, layo
   const prefStore = usePreferences();
   const dynamicTabsStyleRef = useRef();
   const saveAppStateRef = useRef(prefStore?.getPreferencesForModule('misc')?.save_app_state);
-  const { deleteToolData } = useApplicationState() || {};
+  const { deleteToolData } = useApplicationState();
 
   useEffect(()=>{
     layoutDockerObj.eventBus.registerListener(LAYOUT_EVENTS.REMOVE, (panelId)=>{
       layoutDockerObj.close(panelId);
-      deleteToolData?.(panelId);
+      deleteToolData(panelId);
     });
 
     layoutDockerObj.eventBus.registerListener(LAYOUT_EVENTS.CONTEXT, (e, id, extraMenus)=>{
@@ -676,22 +717,6 @@ export default function Layout({groups, noContextGroups, getLayoutInstance, layo
 
   }, [prefStore]);
 
-  const flatDefaultLayout = useMemo(()=>{
-    const flat = [];
-    const flattenLayout = (box)=>{
-      box.children.forEach((child)=>{
-        if(child.children) {
-          flattenLayout(child);
-        }
-        else {
-          flat.push(...(child.tabs ?? []));
-        }
-      });
-    };
-    flattenLayout(props.defaultLayout.dockbox);
-    return flat;
-  }, [props.defaultLayout]);
-
   const getTabMenuItems = (panelId)=>{
     const ret = [];
     if(panelId) {
@@ -731,40 +756,19 @@ export default function Layout({groups, noContextGroups, getLayoutInstance, layo
         });
       }
 
-      // Check for closed default closable tabs that can be re-opened
-      const missingClosableTabs = flatDefaultLayout.filter(
+      // Closed default tabs that can be re-opened, e.g. the Scratch Pad
+      const closedTabs = allowAddPanel ? flatDefaultLayout.filter(
         (t) => t.internal?.closable && !layoutDockerObj.isTabOpen(t.id)
-      );
-      if (missingClosableTabs.length > 0) {
+      ) : [];
+      if(closedTabs.length > 0) {
         ret.push({
           type: 'separator',
         }, {
           label: gettext('Add Panel'),
-          getMenuItems: () => missingClosableTabs.map((tab) => ({
-            label: tab.internal?.title || (typeof tab.title === 'string' ? tab.title : tab.id),
+          getMenuItems: () => closedTabs.map((tab) => ({
+            label: tab.internal?.title || tab.id,
             callback: () => {
-              const flatCurrent = [];
-              const flatten = (box) => {
-                box.children.forEach((child) => {
-                  if (child.children) flatten(child);
-                  else flatCurrent.push(...(child.tabs ?? []));
-                });
-              };
-              const currentDockbox = layoutDockerObj.layoutObj?.getLayout()?.dockbox;
-              if (currentDockbox) {
-                flatten(currentDockbox);
-              }
-              const dockPos = layoutDockerObj.findDefaultDockPosition(tab.id, flatDefaultLayout, flatCurrent);
-              const targetTabId = dockPos?.refTabId || panelId || layoutDockerObj.resetToTabPanel;
-              const targetData = layoutDockerObj.find(targetTabId);
-              const fallbackDirection = targetData?.tabs ? 'middle' : 'after-tab';
-              const direction = dockPos?.direction || fallbackDirection;
-
-              layoutDockerObj.openTab({
-                id: tab.id,
-                content: tab.content,
-                ...tab.internal,
-              }, targetTabId, direction);
+              layoutDockerObj.reopenDefaultTab(tab.id, panelId);
               layoutDockerObj.focus(tab.id);
               layoutDockerObj.saveLayout();
             }
@@ -796,6 +800,22 @@ export default function Layout({groups, noContextGroups, getLayoutInstance, layo
     return savedTab;
   };
 
+  const flatDefaultLayout = useMemo(()=>{
+    const flat = [];
+    const flattenLayout = (box)=>{
+      box.children.forEach((child)=>{
+        if(child.children) {
+          flattenLayout(child);
+        }
+        else {
+          flat.push(...(child.tabs ?? []));
+        }
+      });
+    };
+    flattenLayout(props.defaultLayout.dockbox);
+    return flat;
+  }, [props.defaultLayout]);
+
   const loadTab = (tab)=>{
     const tabData = flatDefaultLayout.find((t)=>t.id == tab.id);
     if(!tabData && tab.metaData) {
@@ -860,7 +880,8 @@ Layout.propTypes = {
   resetToTabPanel: PropTypes.string,
   enableToolEvents: PropTypes.bool,
   isLayoutVisible: PropTypes.bool,
-  className: PropTypes.string
+  className: PropTypes.string,
+  allowAddPanel: PropTypes.bool
 };
 
 
diff --git a/web/pgadmin/tools/sqleditor/static/js/components/QueryToolComponent.jsx b/web/pgadmin/tools/sqleditor/static/js/components/QueryToolComponent.jsx
index 49cb7f5ffc6..533a3ff3316 100644
--- a/web/pgadmin/tools/sqleditor/static/js/components/QueryToolComponent.jsx
+++ b/web/pgadmin/tools/sqleditor/static/js/components/QueryToolComponent.jsx
@@ -1132,6 +1132,7 @@ export default function QueryToolComponent({params, pgWindow, pgAdmin, selectedN
               layoutId="SQLEditor/Layout"
               savedLayout={params.layout}
               resetToTabPanel={PANELS.MESSAGES}
+              allowAddPanel
             />
             <StatusBar eol={qtState.eol} handleEndOfLineChange={handleEndOfLineChange}/>
           </Box>
diff --git a/web/regression/javascript/sqleditor/ScratchPadReopen.spec.js b/web/regression/javascript/sqleditor/ScratchPadReopen.spec.js
index 0bf29e1fc06..82c9e8c2411 100644
--- a/web/regression/javascript/sqleditor/ScratchPadReopen.spec.js
+++ b/web/regression/javascript/sqleditor/ScratchPadReopen.spec.js
@@ -31,12 +31,13 @@ describe('ScratchPad Reopen & LayoutDocker dock positioning', () => {
             },
             {
               size: 75,
+              maximizable: true,
               tabs: [
                 LayoutDocker.getPanel({
                   id: 'id-scratch',
                   title: 'Scratch Pad',
                   closable: true,
-                  content: <textarea data-testid="scratch-pad-area" />,
+                  content: <textarea />,
                 }),
               ],
             },
@@ -56,6 +57,33 @@ describe('ScratchPad Reopen & LayoutDocker dock positioning', () => {
       ],
     },
   };
+  const ThemedLayout = withTheme(Layout);
+
+  let dockerInstance;
+  const renderLayout = (props = {}) => {
+    render(
+      <ApplicationStateProvider>
+        <ThemedLayout
+          defaultLayout={queryToolLayout}
+          layoutId="SQLEditor/Layout"
+          resetToTabPanel="id-messages"
+          getLayoutInstance={(obj) => {
+            dockerInstance = obj;
+          }}
+          {...props}
+        />
+      </ApplicationStateProvider>
+    );
+  };
+
+  const reopenFromMenu = async (rightClickText) => {
+    fireEvent.contextMenu(screen.getByText(rightClickText));
+    fireEvent.click(await screen.findByText('Add Panel'));
+    const item = await screen.findByText('Scratch Pad', { selector: '[role="menuitem"]' });
+    act(() => {
+      fireEvent.click(item);
+    });
+  };
 
   beforeEach(() => {
     getApiInstance.mockReturnValue({
@@ -65,180 +93,85 @@ describe('ScratchPad Reopen & LayoutDocker dock positioning', () => {
   });
 
   describe('findDefaultDockPosition', () => {
-    let layoutDocker;
-
-    beforeEach(() => {
-      layoutDocker = new LayoutDocker('SQLEditor/Layout', queryToolLayout, 'id-messages');
-    });
-
-    it('should find adjacent dock position to the right for Scratch Pad when Query Editor is open', () => {
-      const flatDefault = [
-        { id: 'id-query', title: 'Query' },
-        { id: 'id-history', title: 'Query History' },
-        { id: 'id-scratch', title: 'Scratch Pad', internal: { closable: true } },
-      ];
-      const flatCurrent = [
-        { id: 'id-query', title: 'Query' },
-        { id: 'id-history', title: 'Query History' },
-      ];
-
-      const dockPos = layoutDocker.findDefaultDockPosition('id-scratch', flatDefault, flatCurrent);
-      expect(dockPos).toEqual({
-        refTabId: 'id-query',
-        direction: 'right',
+    it('docks Scratch Pad to the right of the panel holding the open Query tab', () => {
+      renderLayout();
+      act(() => {
+        dockerInstance.close('id-scratch');
       });
-    });
-
-    it('should find middle direction for a tab that shares a tab group with an open sibling', () => {
-      const flatDefault = [
-        { id: 'id-query', title: 'Query' },
-        { id: 'id-history', title: 'Query History' },
-        { id: 'id-scratch', title: 'Scratch Pad', internal: { closable: true } },
-      ];
-      const flatCurrent = [
-        { id: 'id-query', title: 'Query' },
-      ];
-
-      const dockPos = layoutDocker.findDefaultDockPosition('id-history', flatDefault, flatCurrent);
-      expect(dockPos).toEqual({
+      expect(dockerInstance.findDefaultDockPosition('id-scratch')).toEqual({
         refTabId: 'id-query',
-        direction: 'middle',
+        direction: 'right',
       });
     });
-  });
-
-  describe('Layout Context Menu Add Panel', () => {
-    const ThemedLayout = withTheme(Layout);
 
-    it('should show Add Panel menu when closable tab is closed, and reopen it upon click', async () => {
-      let dockerInstance;
-
-      render(
-        <ApplicationStateProvider>
-          <ThemedLayout
-            defaultLayout={queryToolLayout}
-            layoutId="SQLEditor/Layout"
-            resetToTabPanel="id-messages"
-            getLayoutInstance={(obj) => {
-              dockerInstance = obj;
-            }}
-          />
-        </ApplicationStateProvider>
-      );
-
-      // Verify Scratch Pad tab is initially present
-      expect(screen.queryByText('Scratch Pad')).not.toBeNull();
-
-      // Close Scratch Pad
+    it('uses the middle of the group when an open sibling shares the tab group', () => {
+      renderLayout();
       act(() => {
         dockerInstance.close('id-scratch');
       });
+      expect(dockerInstance.findSiblingTab('id-history', (id) => dockerInstance.isTabOpen(id)))
+        .toBe('id-query');
+    });
 
-      expect(dockerInstance.isTabOpen('id-scratch')).toBe(false);
-
-      // Right-click on the Query tab to trigger context menu
-      const queryTabTitle = screen.getByText('Query');
-      fireEvent.contextMenu(queryTabTitle);
-
-      // Context menu should display 'Add Panel'
-      const addPanelMenu = await screen.findByText('Add Panel');
-      expect(addPanelMenu).not.toBeNull();
-
-      // Click or hover on Add Panel to reveal submenu items in react-menu
-      fireEvent.click(addPanelMenu);
-      const scratchSubmenuItem = await screen.findByText('Scratch Pad');
-      expect(scratchSubmenuItem).not.toBeNull();
+    it('returns null when no related tab is open', () => {
+      renderLayout();
+      expect(dockerInstance.findDefaultDockPosition('unknown-tab')).toBeNull();
+    });
+  });
 
-      // Click on Scratch Pad in the submenu to reopen it
+  describe('Add Panel menu', () => {
+    it('is not shown unless allowAddPanel is set', async () => {
+      renderLayout();
       act(() => {
-        fireEvent.click(scratchSubmenuItem);
+        dockerInstance.close('id-scratch');
       });
-
-      // Scratch Pad should now be open again
-      expect(dockerInstance.isTabOpen('id-scratch')).toBe(true);
+      fireEvent.contextMenu(screen.getByText('Query'));
+      await screen.findByText('Close All');
+      expect(screen.queryByText('Add Panel')).toBeNull();
     });
 
-    it('should use "after-tab" fallback direction for tab targets when dockPos has no explicit direction', async () => {
-      let dockerInstance;
-
-      render(
-        <ApplicationStateProvider>
-          <ThemedLayout
-            defaultLayout={queryToolLayout}
-            layoutId="SQLEditor/Layout"
-            resetToTabPanel="id-messages"
-            getLayoutInstance={(obj) => {
-              dockerInstance = obj;
-            }}
-          />
-        </ApplicationStateProvider>
-      );
-
+    it('reopens the Scratch Pad in its own pane to the right of Query, keeping size and maximizable', async () => {
+      renderLayout({ allowAddPanel: true });
       act(() => {
         dockerInstance.close('id-scratch');
       });
+      expect(dockerInstance.isTabOpen('id-scratch')).toBe(false);
 
-      jest.spyOn(dockerInstance, 'findDefaultDockPosition').mockReturnValue(null);
-      const openTabSpy = jest.spyOn(dockerInstance, 'openTab');
-
-      const queryTabTitle = screen.getByText('Query');
-      fireEvent.contextMenu(queryTabTitle);
-
-      const addPanelMenu = await screen.findByText('Add Panel');
-      fireEvent.click(addPanelMenu);
-      const scratchSubmenuItem = await screen.findByText('Scratch Pad');
-
-      act(() => {
-        fireEvent.click(scratchSubmenuItem);
-      });
+      await reopenFromMenu('Query');
 
-      expect(openTabSpy).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'id-scratch' }),
-        'id-query',
-        'after-tab'
-      );
+      expect(dockerInstance.isTabOpen('id-scratch')).toBe(true);
+      const queryPanel = dockerInstance.find('id-query').parent;
+      const scratchPanel = dockerInstance.find('id-scratch').parent;
+      // Query group is untouched, Scratch Pad is not merged into it
+      expect(queryPanel.tabs.map((t) => t.id)).toEqual(['id-query', 'id-history']);
+      expect(scratchPanel.tabs.map((t) => t.id)).toEqual(['id-scratch']);
+      // Both panes sit side by side, with the Scratch Pad on the right
+      expect(scratchPanel.parent).toBe(queryPanel.parent);
+      const siblings = scratchPanel.parent.children;
+      expect(siblings.indexOf(scratchPanel)).toBeGreaterThan(siblings.indexOf(queryPanel));
+      expect(scratchPanel.maximizable).toBe(true);
     });
 
-    it('should use "middle" fallback direction when target resolves to a dock panel without explicit dockPos direction', async () => {
-      let dockerInstance;
-
-      render(
-        <ApplicationStateProvider>
-          <ThemedLayout
-            defaultLayout={queryToolLayout}
-            layoutId="SQLEditor/Layout"
-            resetToTabPanel="id-messages"
-            getLayoutInstance={(obj) => {
-              dockerInstance = obj;
-            }}
-          />
-        </ApplicationStateProvider>
-      );
-
-      act(() => {
+    it('falls back to the right-clicked tab group when no related tab is open', async () => {
+      renderLayout({ allowAddPanel: true });
+      await act(async () => {
         dockerInstance.close('id-scratch');
       });
-
-      const parentPanel = dockerInstance.find('id-query').parent;
-      jest.spyOn(dockerInstance, 'findDefaultDockPosition').mockReturnValue({ refTabId: parentPanel.id });
-      const openTabSpy = jest.spyOn(dockerInstance, 'openTab');
-
-      const queryTabTitle = screen.getByText('Query');
-      fireEvent.contextMenu(queryTabTitle);
-
-      const addPanelMenu = await screen.findByText('Add Panel');
-      fireEvent.click(addPanelMenu);
-      const scratchSubmenuItem = await screen.findByText('Scratch Pad');
-
+      const posSpy = jest.spyOn(dockerInstance, 'findDefaultDockPosition').mockReturnValue(null);
       act(() => {
-        fireEvent.click(scratchSubmenuItem);
+        dockerInstance.reopenDefaultTab('id-scratch', 'id-messages');
       });
+      posSpy.mockRestore();
+      expect(dockerInstance.find('id-scratch').parent.tabs.map((t) => t.id))
+        .toEqual(['id-data-output', 'id-messages', 'id-scratch']);
+    });
 
-      expect(openTabSpy).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'id-scratch' }),
-        parentPanel.id,
-        'middle'
-      );
+    it('does nothing for a tab that is already open', () => {
+      renderLayout({ allowAddPanel: true });
+      const dockMoveSpy = jest.spyOn(dockerInstance.layoutObj, 'dockMove');
+      dockerInstance.reopenDefaultTab('id-scratch', 'id-messages');
+      expect(dockMoveSpy).not.toHaveBeenCalled();
+      dockMoveSpy.mockRestore();
     });
   });
 });