From 5c5816aaa6ff0de6d49f33ea7ec8208c438b6b6f Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Tue, 31 Mar 2026 16:23:46 -0400
Subject: [PATCH 01/12] do not display popup on multi-endpoint disabled to
 users in workspaces

---
 application/single_app/config.py              |  2 +-
 .../js/workspace/workspace_model_endpoints.js | 33 +++++++++
 application/single_app/templates/chats.html   | 11 ++-
 .../templates/group_workspaces.html           |  2 +
 .../single_app/templates/workspace.html       |  2 +
 .../WORKSPACE_ENDPOINTS_DISABLED_TOAST_FIX.md | 45 +++++++++++++
 ...multi_endpoint_notice_template_fallback.py | 46 +++++++++++++
 ...workspace_endpoint_disabled_state_quiet.py | 58 ++++++++++++++++
 ..._chat_page_multi_endpoint_notice_render.py | 47 +++++++++++++
 ..._workspace_page_endpoint_disabled_quiet.py | 67 +++++++++++++++++++
 10 files changed, 306 insertions(+), 7 deletions(-)
 create mode 100644 docs/explanation/fixes/WORKSPACE_ENDPOINTS_DISABLED_TOAST_FIX.md
 create mode 100644 functional_tests/test_chat_multi_endpoint_notice_template_fallback.py
 create mode 100644 functional_tests/test_workspace_endpoint_disabled_state_quiet.py
 create mode 100644 ui_tests/test_chat_page_multi_endpoint_notice_render.py
 create mode 100644 ui_tests/test_workspace_page_endpoint_disabled_quiet.py

diff --git a/application/single_app/config.py b/application/single_app/config.py
index 8bdcc4b0..7d60ed03 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.003"
+VERSION = "0.240.005"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/static/js/workspace/workspace_model_endpoints.js b/application/single_app/static/js/workspace/workspace_model_endpoints.js
index 3f9e3337..612ea15d 100644
--- a/application/single_app/static/js/workspace/workspace_model_endpoints.js
+++ b/application/single_app/static/js/workspace/workspace_model_endpoints.js
@@ -53,6 +53,8 @@ const modelsListEl = document.getElementById("model-endpoint-models-list");
 const addModelBtn = document.getElementById("model-endpoint-add-model-btn");
 
 const scope = window.modelEndpointScope || "user";
+const endpointsContainerId = scope === "group" ? "group-multi-endpoint-configuration" : "workspace-multi-endpoint-configuration";
+const endpointsContainer = document.getElementById(endpointsContainerId);
 const endpointsApi = scope === "group" ? "/api/group/model-endpoints" : "/api/user/model-endpoints";
 const modelsFetchApi = scope === "group" ? "/api/group/models/fetch" : "/api/user/models/fetch";
 const modelsTestApi = scope === "group" ? "/api/group/models/test-model" : "/api/user/models/test-model";
@@ -60,6 +62,21 @@ const modelsTestApi = scope === "group" ? "/api/group/models/test-model" : "/api
 let workspaceEndpoints = Array.isArray(window.workspaceModelEndpoints) ? [...window.workspaceModelEndpoints] : [];
 let modalModels = [];
 
+function hasEndpointManagementUi() {
+    return Boolean(endpointsWrapper && endpointsTbody);
+}
+
+function hideEndpointManagementUi() {
+    if (endpointsContainer) {
+        endpointsContainer.classList.add("d-none");
+    }
+}
+
+function isEndpointsFeatureDisabled(error) {
+    const message = typeof error?.message === "string" ? error.message.toLowerCase() : "";
+    return message.includes("custom endpoints") && message.includes("is disabled");
+}
+
 function generateId() {
     if (window.crypto && window.crypto.randomUUID) {
         return window.crypto.randomUUID();
@@ -620,6 +637,10 @@ function escapeHtml(value) {
 }
 
 async function loadEndpoints() {
+    if (!hasEndpointManagementUi()) {
+        return;
+    }
+
     try {
         const response = await fetch(endpointsApi);
         const payload = await response.json().catch(() => ({}));
@@ -629,12 +650,24 @@ async function loadEndpoints() {
         workspaceEndpoints = Array.isArray(payload.endpoints) ? payload.endpoints : [];
         renderEndpoints();
     } catch (error) {
+        if (isEndpointsFeatureDisabled(error)) {
+            console.info("[WorkspaceEndpoints] Endpoint management is disabled; skipping endpoint load.");
+            workspaceEndpoints = [];
+            renderEndpoints();
+            hideEndpointManagementUi();
+            return;
+        }
+
         console.error("Failed to load endpoints", error);
         showToast(error.message || "Failed to load endpoints.", "danger");
     }
 }
 
 function initialize() {
+    if (!hasEndpointManagementUi()) {
+        return;
+    }
+
     if (enableMultiEndpointToggle) {
         enableMultiEndpointToggle.checked = Boolean(window.enableMultiModelEndpoints);
     }
diff --git a/application/single_app/templates/chats.html b/application/single_app/templates/chats.html
index 73d26ff3..559ca949 100644
--- a/application/single_app/templates/chats.html
+++ b/application/single_app/templates/chats.html
@@ -1,4 +1,5 @@
 {% extends "base.html" %}
+{% set multi_endpoint_notice_data = multi_endpoint_notice|default({}) %}
 {% block title %}
     Chats - {{ app_settings.app_title }}
 {% endblock %}
@@ -289,19 +290,17 @@ <h5 id="current-conversation-title" class="mb-0 flex-grow-1">
                 <!-- Chat messages will be dynamically loaded here -->
             </div>
 
-            <!--
-            {% if multi_endpoint_notice.enabled %}
-            <div id="multi-endpoint-notice" class="alert alert-warning d-none mx-3 mb-0" data-message="{{ multi_endpoint_notice.message }}">
+            {% if multi_endpoint_notice_data.enabled %}
+            <div id="multi-endpoint-notice" class="alert alert-warning d-none mx-3 mb-0" data-message="{{ multi_endpoint_notice_data.message }}">
                 <div class="d-flex justify-content-between align-items-center">
                     <div class="me-3">
                         <i class="bi bi-exclamation-triangle me-2"></i>
-                        <span id="multi-endpoint-notice-text">{{ multi_endpoint_notice.message }}</span>
+                        <span id="multi-endpoint-notice-text">{{ multi_endpoint_notice_data.message }}</span>
                     </div>
                     <button type="button" class="btn btn-sm btn-outline-dark" id="dismiss-multi-endpoint-notice">Dismiss</button>
                 </div>
             </div>
             {% endif %}
-            -->
 
             <div class="p-3 border-top flex-shrink-0">
                 
@@ -1166,7 +1165,7 @@ <h5 class="modal-title" id="scopeLockModalLabel">
         enable_thoughts: JSON.parse('{{ 'true' if settings.enable_thoughts else 'false' }}')
     };
 
-    window.multiEndpointNotice = JSON.parse('{{ multi_endpoint_notice|tojson()|safe }}');
+    window.multiEndpointNotice = JSON.parse('{{ multi_endpoint_notice_data|tojson()|safe }}');
 
     // Layout related globals (can stay here or move entirely into chat-layout.js if preferred)
     let splitInstance = null;
diff --git a/application/single_app/templates/group_workspaces.html b/application/single_app/templates/group_workspaces.html
index ae78acab..7a13cf75 100644
--- a/application/single_app/templates/group_workspaces.html
+++ b/application/single_app/templates/group_workspaces.html
@@ -1454,7 +1454,9 @@ <h5 class="modal-title" id="groupTagSelectionModalLabel">Select Tags</h5>
     window.workspaceModelEndpoints = JSON.parse('{{ group_model_endpoints|default([])|tojson|safe }}' || '[]');
     window.globalModelEndpoints = JSON.parse('{{ global_model_endpoints|default([])|tojson|safe }}' || '[]');
 </script>
+{% if settings.enable_semantic_kernel and settings.allow_group_custom_endpoints and settings.enable_multi_model_endpoints %}
 <script type="module" src="{{ url_for('static', filename='js/workspace/workspace_model_endpoints.js') }}"></script>
+{% endif %}
 
 <!-- Pass backend flags to JS -->
 <script>
diff --git a/application/single_app/templates/workspace.html b/application/single_app/templates/workspace.html
index b5ef16c3..6a46f0af 100644
--- a/application/single_app/templates/workspace.html
+++ b/application/single_app/templates/workspace.html
@@ -1548,7 +1548,9 @@ <h5 class="modal-title" id="approveSharedModalLabel">Approve Shared Document</h5
     window.workspaceModelEndpoints = JSON.parse('{{ personal_model_endpoints|default([])|tojson|safe }}' || '[]');
     window.globalModelEndpoints = JSON.parse('{{ global_model_endpoints|default([])|tojson|safe }}' || '[]');
   </script>
+  {% if settings.per_user_semantic_kernel and settings.enable_semantic_kernel and settings.allow_user_custom_endpoints and settings.enable_multi_model_endpoints %}
   <script type="module" src="{{ url_for('static', filename='js/workspace/workspace_model_endpoints.js') }}"></script>
+  {% endif %}
   <!-- <script src="https://cdn.jsdelivr.net/npm/simplemde/dist/simplemde.min.js"></script>
    LOCAL VERSION BELOW -->
    <script src="/static/js/simplemde/simplemde.min.js"></script>
diff --git a/docs/explanation/fixes/WORKSPACE_ENDPOINTS_DISABLED_TOAST_FIX.md b/docs/explanation/fixes/WORKSPACE_ENDPOINTS_DISABLED_TOAST_FIX.md
new file mode 100644
index 00000000..40cb4d65
--- /dev/null
+++ b/docs/explanation/fixes/WORKSPACE_ENDPOINTS_DISABLED_TOAST_FIX.md
@@ -0,0 +1,45 @@
+# WORKSPACE_ENDPOINTS_DISABLED_TOAST_FIX
+
+Fixed in version: **0.240.005**
+
+## Issue Description
+
+The personal and group workspace pages always loaded the endpoint-management JavaScript module, even when custom endpoints or multi-endpoint support were intentionally disabled by the administrator.
+
+## Root Cause Analysis
+
+The endpoints tab markup was correctly gated in the templates, but the shared workspace endpoint module was still included unconditionally in the page scripts. That module immediately called the disabled endpoint API and surfaced the backend `Allow User Custom Endpoints is disabled.` error as a toast.
+
+## Technical Details
+
+Files modified:
+
+- `application/single_app/static/js/workspace/workspace_model_endpoints.js`
+- `application/single_app/templates/workspace.html`
+- `application/single_app/templates/group_workspaces.html`
+- `application/single_app/config.py`
+- `functional_tests/test_workspace_endpoint_disabled_state_quiet.py`
+- `ui_tests/test_workspace_page_endpoint_disabled_quiet.py`
+
+Code changes summary:
+
+- Added a DOM guard so the workspace endpoint module skips initialization when the endpoints UI is not rendered.
+- Added disabled-feature detection so a stale or race-condition `custom endpoints is disabled` response is handled quietly instead of showing a user-facing error toast.
+- Gated the workspace and group endpoint module include behind the same template conditions that render the endpoints tabs.
+
+Testing approach:
+
+- Added a functional regression test that verifies the JS guard and template gating.
+- Added a UI regression test that confirms the workspace page does not request the disabled endpoints API or emit the disabled-feature error when the tab is absent.
+
+## Validation
+
+Before:
+
+- Workspace pages without endpoint management still requested `/api/user/model-endpoints`.
+- Users saw a red toast saying custom endpoints were disabled, even though the feature was intentionally off.
+
+After:
+
+- The endpoint module only initializes when the endpoints UI is present.
+- Disabled configurations stay quiet and do not show the endpoint error toast to end users.
\ No newline at end of file
diff --git a/functional_tests/test_chat_multi_endpoint_notice_template_fallback.py b/functional_tests/test_chat_multi_endpoint_notice_template_fallback.py
new file mode 100644
index 00000000..c98444a4
--- /dev/null
+++ b/functional_tests/test_chat_multi_endpoint_notice_template_fallback.py
@@ -0,0 +1,46 @@
+# test_chat_multi_endpoint_notice_template_fallback.py
+#!/usr/bin/env python3
+"""
+Functional test for chat multi-endpoint notice template fallback.
+Version: 0.240.004
+Implemented in: 0.240.004
+
+This test ensures the chats template safely defaults the multi-endpoint notice
+context, renders the notice markup only when enabled, and avoids Jinja
+undefined errors when the route does not pass the notice object.
+"""
+
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+CHAT_TEMPLATE = REPO_ROOT / "application" / "single_app" / "templates" / "chats.html"
+CONFIG_FILE = REPO_ROOT / "application" / "single_app" / "config.py"
+
+
+def test_chat_multi_endpoint_notice_template_fallback():
+    """Verify the chats template safely handles a missing notice context."""
+    template_content = CHAT_TEMPLATE.read_text(encoding="utf-8")
+    config_content = CONFIG_FILE.read_text(encoding="utf-8")
+
+    assert 'VERSION = "0.240.004"' in config_content, "Expected config.py version 0.240.004"
+    assert '{% set multi_endpoint_notice_data = multi_endpoint_notice|default({}) %}' in template_content, (
+        "Expected chats.html to define a safe default for multi_endpoint_notice."
+    )
+    assert '{% if multi_endpoint_notice_data.enabled %}' in template_content, (
+        "Expected the chat multi-endpoint notice markup to be conditionally rendered."
+    )
+    assert 'id="multi-endpoint-notice"' in template_content, (
+        "Expected chats.html to keep the multi-endpoint notice container for chat-onload.js."
+    )
+    assert 'window.multiEndpointNotice = JSON.parse(\'{{ multi_endpoint_notice_data|tojson()|safe }}\');' in template_content, (
+        "Expected chats.html to serialize the safe default notice object for chat-onload.js."
+    )
+    assert '<!--\n            {% if multi_endpoint_notice.enabled %}' not in template_content, (
+        "Expected chats.html to remove the HTML comment wrapper around active Jinja markup."
+    )
+
+
+if __name__ == "__main__":
+    test_chat_multi_endpoint_notice_template_fallback()
+    print("✅ Chat multi-endpoint notice template fallback verified.")
diff --git a/functional_tests/test_workspace_endpoint_disabled_state_quiet.py b/functional_tests/test_workspace_endpoint_disabled_state_quiet.py
new file mode 100644
index 00000000..b0652b97
--- /dev/null
+++ b/functional_tests/test_workspace_endpoint_disabled_state_quiet.py
@@ -0,0 +1,58 @@
+# test_workspace_endpoint_disabled_state_quiet.py
+#!/usr/bin/env python3
+"""
+Functional test for workspace endpoint disabled-state suppression.
+Version: 0.240.005
+Implemented in: 0.240.005
+
+This test ensures the workspace endpoint module only loads when the endpoints
+UI is rendered and quietly suppresses disabled-feature responses instead of
+showing user-facing errors.
+"""
+
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+CONFIG_FILE = REPO_ROOT / "application" / "single_app" / "config.py"
+WORKSPACE_JS = REPO_ROOT / "application" / "single_app" / "static" / "js" / "workspace" / "workspace_model_endpoints.js"
+WORKSPACE_TEMPLATE = REPO_ROOT / "application" / "single_app" / "templates" / "workspace.html"
+GROUP_TEMPLATE = REPO_ROOT / "application" / "single_app" / "templates" / "group_workspaces.html"
+
+
+def test_workspace_endpoint_disabled_state_quiet():
+    """Verify endpoint management stays quiet when the feature is unavailable."""
+    config_content = CONFIG_FILE.read_text(encoding="utf-8")
+    js_content = WORKSPACE_JS.read_text(encoding="utf-8")
+    workspace_template = WORKSPACE_TEMPLATE.read_text(encoding="utf-8")
+    group_template = GROUP_TEMPLATE.read_text(encoding="utf-8")
+
+    assert 'VERSION = "0.240.005"' in config_content, "Expected config.py version 0.240.005"
+    assert "function hasEndpointManagementUi()" in js_content, (
+        "Expected workspace_model_endpoints.js to detect whether the endpoints UI exists."
+    )
+    assert "return Boolean(endpointsWrapper && endpointsTbody);" in js_content, (
+        "Expected workspace_model_endpoints.js to require the endpoints wrapper and table body before initializing."
+    )
+    assert "if (!hasEndpointManagementUi()) {" in js_content, (
+        "Expected workspace_model_endpoints.js to skip initialization when the endpoints UI is absent."
+    )
+    assert "function isEndpointsFeatureDisabled(error)" in js_content, (
+        "Expected workspace_model_endpoints.js to recognize disabled endpoint-feature responses."
+    )
+    assert 'console.info("[WorkspaceEndpoints] Endpoint management is disabled; skipping endpoint load.");' in js_content, (
+        "Expected disabled endpoint loads to be logged quietly instead of shown as a toast."
+    )
+    assert (
+        "{% if settings.per_user_semantic_kernel and settings.enable_semantic_kernel and settings.allow_user_custom_endpoints and settings.enable_multi_model_endpoints %}"
+        in workspace_template
+    ), "Expected workspace.html to gate the endpoint module behind the same conditions as the endpoints tab."
+    assert (
+        "{% if settings.enable_semantic_kernel and settings.allow_group_custom_endpoints and settings.enable_multi_model_endpoints %}"
+        in group_template
+    ), "Expected group_workspaces.html to gate the endpoint module behind the same conditions as the group endpoints tab."
+
+
+if __name__ == "__main__":
+    test_workspace_endpoint_disabled_state_quiet()
+    print("✅ Workspace endpoint disabled-state suppression verified.")
\ No newline at end of file
diff --git a/ui_tests/test_chat_page_multi_endpoint_notice_render.py b/ui_tests/test_chat_page_multi_endpoint_notice_render.py
new file mode 100644
index 00000000..282578ea
--- /dev/null
+++ b/ui_tests/test_chat_page_multi_endpoint_notice_render.py
@@ -0,0 +1,47 @@
+# test_chat_page_multi_endpoint_notice_render.py
+"""
+UI test for chat page multi-endpoint notice rendering.
+Version: 0.240.004
+Implemented in: 0.240.004
+
+This test ensures the authenticated chats page loads successfully and renders
+the primary chat UI without a server-side template failure.
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+
+BASE_URL = os.getenv("SIMPLECHAT_UI_BASE_URL", "").rstrip("/")
+STORAGE_STATE = os.getenv("SIMPLECHAT_UI_STORAGE_STATE", "")
+
+
+@pytest.mark.ui
+def test_chat_page_multi_endpoint_notice_render(playwright):
+    """Validate that the chats page renders for an authenticated user."""
+    if not BASE_URL:
+        pytest.skip("Set SIMPLECHAT_UI_BASE_URL to run this UI test.")
+    if not STORAGE_STATE or not Path(STORAGE_STATE).exists():
+        pytest.skip("Set SIMPLECHAT_UI_STORAGE_STATE to a valid authenticated Playwright storage state file.")
+
+    browser = playwright.chromium.launch()
+    context = browser.new_context(
+        storage_state=STORAGE_STATE,
+        viewport={"width": 1440, "height": 900},
+    )
+    page = context.new_page()
+
+    try:
+        response = page.goto(f"{BASE_URL}/chats", wait_until="domcontentloaded")
+
+        assert response is not None, "Expected a navigation response when loading /chats."
+        assert response.ok, f"Expected /chats to load successfully, got HTTP {response.status}."
+
+        expect(page.locator("#chatbox")).to_be_visible()
+        expect(page.locator("#user-input")).to_be_visible()
+    finally:
+        context.close()
+        browser.close()
diff --git a/ui_tests/test_workspace_page_endpoint_disabled_quiet.py b/ui_tests/test_workspace_page_endpoint_disabled_quiet.py
new file mode 100644
index 00000000..36ea9fc7
--- /dev/null
+++ b/ui_tests/test_workspace_page_endpoint_disabled_quiet.py
@@ -0,0 +1,67 @@
+# test_workspace_page_endpoint_disabled_quiet.py
+"""
+UI test for workspace endpoint-disabled UX.
+Version: 0.240.005
+Implemented in: 0.240.005
+
+This test ensures a workspace page that does not expose the endpoints tab does
+not request the disabled endpoint API or show the disabled-feature error.
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+
+BASE_URL = os.getenv("SIMPLECHAT_UI_BASE_URL", "").rstrip("/")
+STORAGE_STATE = os.getenv("SIMPLECHAT_UI_STORAGE_STATE", "")
+
+
+@pytest.mark.ui
+def test_workspace_page_endpoint_disabled_quiet(playwright):
+    """Validate that workspace loads quietly when endpoints are disabled."""
+    if not BASE_URL:
+        pytest.skip("Set SIMPLECHAT_UI_BASE_URL to run this UI test.")
+    if not STORAGE_STATE or not Path(STORAGE_STATE).exists():
+        pytest.skip("Set SIMPLECHAT_UI_STORAGE_STATE to a valid authenticated Playwright storage state file.")
+
+    browser = playwright.chromium.launch()
+    context = browser.new_context(
+        storage_state=STORAGE_STATE,
+        viewport={"width": 1440, "height": 900},
+    )
+    page = context.new_page()
+    endpoint_requests = []
+    console_errors = []
+
+    def track_request(request):
+        if "/api/user/model-endpoints" in request.url:
+            endpoint_requests.append(request.url)
+
+    def track_console(message):
+        if message.type == "error":
+            console_errors.append(message.text)
+
+    page.on("request", track_request)
+    page.on("console", track_console)
+
+    try:
+        response = page.goto(f"{BASE_URL}/workspace", wait_until="networkidle")
+
+        assert response is not None, "Expected a navigation response when loading /workspace."
+        assert response.ok, f"Expected /workspace to load successfully, got HTTP {response.status}."
+
+        if page.locator("#endpoints-tab-btn").count() > 0:
+            pytest.skip("Personal endpoint management is enabled in this environment.")
+
+        expect(page.locator("#documents-tab")).to_be_visible()
+        expect(page.get_by_text("Allow User Custom Endpoints is disabled.")).to_have_count(0)
+        assert endpoint_requests == [], "Expected no user model-endpoints request when the endpoints tab is hidden."
+        assert not any("Failed to load endpoints" in message for message in console_errors), (
+            "Expected the workspace page to avoid endpoint-load console errors when personal endpoints are disabled."
+        )
+    finally:
+        context.close()
+        browser.close()
\ No newline at end of file

From 5f2c3eb2aadc5922d18eceaed1b2a3f91ab6e249 Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Wed, 1 Apr 2026 09:43:16 -0400
Subject: [PATCH 02/12] fixed model selection for legacy gpt

---
 application/single_app/config.py              |   2 +-
 application/single_app/route_backend_chats.py | 151 ++++++++++++++++--
 .../tabular_processing_plugin.py              |  31 +++-
 .../static/js/chat/chat-model-selector.js     |  18 +++
 .../single_app/templates/_agent_modal.html    |   2 +-
 .../templates/_multiendpoint_modal.html       |   6 +-
 application/single_app/templates/chats.html   |  42 ++---
 .../templates/group_workspaces.html           | 119 ++++++++++++--
 .../single_app/templates/workspace.html       |  81 +++++++++-
 ...CHAT_LEGACY_MODEL_SELECTION_RESTORE_FIX.md |  43 +++++
 .../fixes/CHAT_TEMPLATE_JSON_BOOTSTRAP_FIX.md |  49 ++++++
 ...WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md |  29 ++++
 ...ULTISHEET_ENTITY_LOOKUP_RELIABILITY_FIX.md |  52 ++++++
 ...WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md |  32 ++++
 ...multi_endpoint_notice_template_fallback.py |  18 ++-
 ...est_chat_template_json_bootstrap_safety.py |  80 ++++++++++
 ...oup_workspace_autofill_overlay_metadata.py |  69 ++++++++
 .../test_reasoning_effort_initial_sync.py     |  66 ++++++--
 .../test_tabular_entity_lookup_mode.py        |  72 ++++++++-
 ...est_tabular_multisheet_workbook_support.py |  37 ++++-
 ...est_workspace_autofill_overlay_metadata.py |  89 +++++++++++
 ..._chat_page_multi_endpoint_notice_render.py |  36 ++++-
 ..._group_workspace_page_autofill_metadata.py |  73 +++++++++
 .../test_workspace_page_autofill_metadata.py  |  69 ++++++++
 24 files changed, 1176 insertions(+), 90 deletions(-)
 create mode 100644 docs/explanation/fixes/CHAT_LEGACY_MODEL_SELECTION_RESTORE_FIX.md
 create mode 100644 docs/explanation/fixes/CHAT_TEMPLATE_JSON_BOOTSTRAP_FIX.md
 create mode 100644 docs/explanation/fixes/GROUP_WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md
 create mode 100644 docs/explanation/fixes/TABULAR_MULTISHEET_ENTITY_LOOKUP_RELIABILITY_FIX.md
 create mode 100644 docs/explanation/fixes/WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md
 create mode 100644 functional_tests/test_chat_template_json_bootstrap_safety.py
 create mode 100644 functional_tests/test_group_workspace_autofill_overlay_metadata.py
 create mode 100644 functional_tests/test_workspace_autofill_overlay_metadata.py
 create mode 100644 ui_tests/test_group_workspace_page_autofill_metadata.py
 create mode 100644 ui_tests/test_workspace_page_autofill_metadata.py

diff --git a/application/single_app/config.py b/application/single_app/config.py
index 7d60ed03..0e24fd64 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.005"
+VERSION = "0.240.010"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/route_backend_chats.py b/application/single_app/route_backend_chats.py
index 8e58ad8b..2f40fb54 100644
--- a/application/single_app/route_backend_chats.py
+++ b/application/single_app/route_backend_chats.py
@@ -1190,6 +1190,80 @@ def _tokenize_tabular_sheet_text(text):
     return tokens
 
 
+def _extract_tabular_entity_anchor_terms(question_text):
+    """Extract likely primary-entity terms from an entity lookup question."""
+    normalized_question = str(question_text or '').strip().lower()
+    if not normalized_question:
+        return []
+
+    stopwords = {
+        'and',
+        'any',
+        'by',
+        'detail',
+        'details',
+        'exact',
+        'explain',
+        'find',
+        'for',
+        'from',
+        'full',
+        'get',
+        'give',
+        'lookup',
+        'me',
+        'of',
+        'or',
+        'profile',
+        'profiles',
+        'record',
+        'records',
+        'related',
+        'show',
+        'story',
+        'summaries',
+        'summarize',
+        'summary',
+        'that',
+        'the',
+        'their',
+        'this',
+        'those',
+        'these',
+        'to',
+        'up',
+        'with',
+    }
+    capture_patterns = (
+        r'\bfind\s+([^\.;:!?]+)',
+        r'\blookup\s+([^\.;:!?]+)',
+    )
+    anchor_terms = []
+    seen_anchor_terms = set()
+
+    for capture_pattern in capture_patterns:
+        match = re.search(capture_pattern, normalized_question)
+        if not match:
+            continue
+
+        captured_text = re.split(
+            r'\b(?:and|show|summarize|summary|profile|with|where|which|who|that)\b',
+            match.group(1),
+            maxsplit=1,
+        )[0]
+        for token in _tokenize_tabular_sheet_text(captured_text):
+            if token in stopwords:
+                continue
+            if any(character.isdigit() for character in token):
+                continue
+            if token in seen_anchor_terms:
+                continue
+            seen_anchor_terms.add(token)
+            anchor_terms.append(token)
+
+    return anchor_terms
+
+
 def _score_tabular_sheet_match(sheet_name, question_text, columns=None):
     """Score how strongly a worksheet name matches the user question.
 
@@ -1228,15 +1302,54 @@ def _score_tabular_sheet_match(sheet_name, question_text, columns=None):
     return score
 
 
-def _select_relevant_workbook_sheets(sheet_names, question_text, minimum_score=1, per_sheet=None):
+def _score_tabular_entity_sheet_match(sheet_name, question_text, columns=None):
+    """Score worksheets for entity lookups, prioritizing the primary entity sheet."""
+    score = _score_tabular_sheet_match(sheet_name, question_text, columns=columns)
+    anchor_terms = _extract_tabular_entity_anchor_terms(question_text)
+    if not anchor_terms:
+        return score
+
+    question_tokens = set(_tokenize_tabular_sheet_text(question_text))
+    sheet_tokens = set(_tokenize_tabular_sheet_text(sheet_name))
+    column_tokens = set()
+    for column_name in columns or []:
+        column_tokens.update(_tokenize_tabular_sheet_text(column_name))
+
+    for anchor_term in anchor_terms:
+        if anchor_term in sheet_tokens:
+            score += 12
+        elif anchor_term in column_tokens:
+            score += 4
+
+    if 'profile' in question_tokens and column_tokens.intersection({
+        'address',
+        'city',
+        'displayname',
+        'dob',
+        'email',
+        'firstname',
+        'fullname',
+        'lastname',
+        'name',
+        'phone',
+        'state',
+        'status',
+    }):
+        score += 6
+
+    return score
+
+
+def _select_relevant_workbook_sheets(sheet_names, question_text, minimum_score=1, per_sheet=None, score_match_fn=None):
     """Return all workbook sheets that appear relevant to the question."""
+    score_match_fn = score_match_fn or _score_tabular_sheet_match
     ranked_sheets = []
     for sheet_name in sheet_names or []:
         columns = None
         if per_sheet:
             sheet_info = per_sheet.get(sheet_name, {})
             columns = sheet_info.get('columns', [])
-        score = _score_tabular_sheet_match(sheet_name, question_text, columns=columns)
+        score = score_match_fn(sheet_name, question_text, columns=columns)
         if score < minimum_score:
             continue
         ranked_sheets.append((score, sheet_name))
@@ -1323,8 +1436,9 @@ def is_tabular_access_limited_analysis(analysis_text):
     return any(phrase in normalized_analysis for phrase in inaccessible_phrases)
 
 
-def _select_likely_workbook_sheet(sheet_names, question_text, per_sheet=None):
+def _select_likely_workbook_sheet(sheet_names, question_text, per_sheet=None, score_match_fn=None):
     """Return a likely sheet name when the user question strongly matches one sheet."""
+    score_match_fn = score_match_fn or _score_tabular_sheet_match
     best_sheet = None
     best_score = 0
     runner_up_score = 0
@@ -1334,7 +1448,7 @@ def _select_likely_workbook_sheet(sheet_names, question_text, per_sheet=None):
         if per_sheet:
             sheet_info = per_sheet.get(sheet_name, {})
             columns = sheet_info.get('columns', [])
-        score = _score_tabular_sheet_match(sheet_name, question_text, columns=columns)
+        score = score_match_fn(sheet_name, question_text, columns=columns)
 
         if score > best_score:
             runner_up_score = best_score
@@ -1427,6 +1541,7 @@ async def run_tabular_sk_analysis(user_question, tabular_filenames, user_id,
         workbook_blob_locations = {}
         retry_sheet_overrides = {}
         previous_failed_call_parameters = []  # entity lookup: concrete failed call params for retry hints
+        sheet_score_match_fn = _score_tabular_entity_sheet_match if entity_lookup_mode else _score_tabular_sheet_match
         allowed_function_filters = {
             'included_functions': [
                 f"tabular_processing-{function_name}"
@@ -1459,11 +1574,13 @@ async def run_tabular_sk_analysis(user_question, tabular_filenames, user_id,
                         schema_info.get('sheet_names', []),
                         user_question,
                         per_sheet=per_sheet,
+                        score_match_fn=sheet_score_match_fn,
                     )
                     relevant_sheets = _select_relevant_workbook_sheets(
                         schema_info.get('sheet_names', []),
                         user_question,
                         per_sheet=per_sheet,
+                        score_match_fn=sheet_score_match_fn,
                     )
                     cross_sheet_bridge_plan = None
                     if not schema_summary_mode and not entity_lookup_mode:
@@ -1739,19 +1856,22 @@ def build_system_prompt(force_tool_use=False, tool_error_messages=None, executio
                     f"{missing_sheet_feedback}"
                     f"FILE SCHEMAS:\n"
                     f"{schema_context}\n\n"
-                    "AVAILABLE FUNCTIONS: lookup_value, aggregate_column, filter_rows, query_tabular_data, "
+                    "AVAILABLE FUNCTIONS: filter_rows, query_tabular_data, lookup_value, aggregate_column, "
                     "group_by_aggregate, and group_by_datetime_component.\n\n"
                     "Discovery functions are not available in this analysis run because schema context is already pre-loaded.\n\n"
                     "IMPORTANT:\n"
-                    "1. Pass sheet_name='<name>' on EVERY analytical call for multi-sheet workbooks. Do not rely on a default sheet for cross-sheet entity lookups.\n"
-                    "2. First retrieve the primary entity row on the most relevant worksheet.\n"
-                    "3. Then query other relevant worksheets explicitly to collect related records.\n"
-                    "4. When a retrieved row contains a secondary identifier such as ReturnID, CaseID, AccountID, PaymentID, W2ID, or Form1099ID, reuse it to query dependent worksheets.\n"
-                    "5. Do not stop after the first successful row if the question asks for related records across sheets.\n"
-                    "6. If a requested record type has no corresponding worksheet in the workbook, say that the workbook does not contain that record type.\n"
-                    "7. Clearly distinguish between no matching rows and no corresponding worksheet.\n"
-                    "8. Summarize concrete found records sheet-by-sheet using the tool results, not schema placeholders.\n"
-                    "9. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report."
+                    "1. If the question includes an exact identifier or exact entity name and the correct starting worksheet is unclear, begin with filter_rows or query_tabular_data without sheet_name so the plugin can perform a cross-sheet discovery search.\n"
+                    "2. After the first discovery step, pass sheet_name='<name>' on follow-up analytical calls for multi-sheet workbooks. Do not rely on a default sheet for cross-sheet entity lookups.\n"
+                    "3. Use filter_rows or query_tabular_data first when you need full matching rows. Use lookup_value only when you already know the exact worksheet and target column.\n"
+                    "4. Do not start with aggregate_column, group_by_aggregate, or group_by_datetime_component until you have located the relevant entity rows.\n"
+                    "5. When using query_tabular_data, use simple DataFrame.query() syntax with backticked column names for columns containing spaces. Avoid method calls such as .str.lower() or .astype(...).\n"
+                    "6. Then query other relevant worksheets explicitly to collect related records.\n"
+                    "7. When a retrieved row contains a secondary identifier such as ReturnID, CaseID, AccountID, PaymentID, W2ID, or Form1099ID, reuse it to query dependent worksheets.\n"
+                    "8. Do not stop after the first successful row if the question asks for related records across sheets.\n"
+                    "9. If a requested record type has no corresponding worksheet in the workbook, say that the workbook does not contain that record type.\n"
+                    "10. Clearly distinguish between no matching rows and no corresponding worksheet.\n"
+                    "11. Summarize concrete found records sheet-by-sheet using the tool results, not schema placeholders.\n"
+                    "12. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report."
                 )
 
             return (
@@ -1790,7 +1910,8 @@ def build_system_prompt(force_tool_use=False, tool_error_messages=None, executio
                 "14. For identifier-based workbook questions, locate the identifier on the correct sheet before explaining downstream calculations.\n"
                 "15. For peak, busiest, highest, or lowest questions, use grouped functions and inspect the highest_group, highest_value, lowest_group, and lowest_value summary fields.\n"
                 "16. Return only computed findings and name the strongest drivers clearly.\n"
-                "17. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report."
+                "17. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report.\n"
+                "18. When using query_tabular_data, use simple DataFrame.query() syntax with backticked column names for columns containing spaces. Avoid method calls such as .str.lower(), .astype(...), or other Python expressions that DataFrame.query() may reject."
             )
 
         baseline_invocations = plugin_logger.get_invocations_for_conversation(
diff --git a/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py b/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
index fd5e2597..c574cbbb 100644
--- a/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
+++ b/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
@@ -465,6 +465,7 @@ def _query_tabular_data_across_sheets(
         sheets_searched = []
         sheets_matched = []
         total_matches = 0
+        query_errors = []
 
         for sheet in available_sheets:
             df = self._read_tabular_blob_to_dataframe(
@@ -476,8 +477,11 @@ def _query_tabular_data_across_sheets(
 
             try:
                 result_df = df.query(query_expression)
-            except Exception:
-                # Query expression references columns not in this sheet — skip
+            except Exception as query_error:
+                query_errors.append({
+                    'sheet_name': sheet,
+                    'error': str(query_error),
+                })
                 continue
 
             sheets_searched.append(sheet)
@@ -494,6 +498,29 @@ def _query_tabular_data_across_sheets(
                     combined_results.append(row)
 
         if not sheets_searched:
+            if query_errors:
+                unique_errors = []
+                seen_errors = set()
+                for query_error in query_errors:
+                    normalized_error = str(query_error.get('error') or '').strip()
+                    if not normalized_error or normalized_error in seen_errors:
+                        continue
+                    seen_errors.add(normalized_error)
+                    unique_errors.append(normalized_error)
+
+                return json.dumps({
+                    "error": (
+                        "Query error: the expression could not be evaluated on any worksheet during cross-sheet search. "
+                        "Use simple DataFrame.query() syntax with existing column names, or provide sheet_name to target a specific worksheet."
+                    ),
+                    "filename": filename,
+                    "selected_sheet": "ALL (cross-sheet search)",
+                    "query_expression": query_expression,
+                    "sheets_evaluated": [
+                        query_error['sheet_name'] for query_error in query_errors
+                    ],
+                    "details": unique_errors[:3],
+                }, indent=2, default=str)
             return None
 
         log_event(
diff --git a/application/single_app/static/js/chat/chat-model-selector.js b/application/single_app/static/js/chat/chat-model-selector.js
index f5216d96..3c4c5daa 100644
--- a/application/single_app/static/js/chat/chat-model-selector.js
+++ b/application/single_app/static/js/chat/chat-model-selector.js
@@ -209,6 +209,23 @@ function getSelectionSnapshot() {
     };
 }
 
+function restoreLegacyPreferredModelSelection(preferredModelDeployment) {
+    if (!modelSelect || !preferredModelDeployment) {
+        return;
+    }
+
+    const matchingOption = Array.from(modelSelect.options).find(option => (
+        option.value === preferredModelDeployment
+            || option.dataset.deploymentName === preferredModelDeployment
+    ));
+
+    if (!matchingOption || matchingOption.disabled) {
+        return;
+    }
+
+    modelSelect.value = matchingOption.value;
+}
+
 function resolveSelectedSelectionKey(options, restoreOptions = {}) {
     const {
         currentSelection = null,
@@ -486,6 +503,7 @@ export async function populateModelDropdown(restoreOptions = {}) {
     }
 
     if (!window.appSettings?.enable_multi_model_endpoints) {
+        restoreLegacyPreferredModelSelection(restoreOptions.preferredModelDeployment || null);
         modelSelectorController?.refresh();
         return;
     }
diff --git a/application/single_app/templates/_agent_modal.html b/application/single_app/templates/_agent_modal.html
index a859aed9..ef7fefc5 100644
--- a/application/single_app/templates/_agent_modal.html
+++ b/application/single_app/templates/_agent_modal.html
@@ -1,5 +1,5 @@
 <!-- Dynamic Agent Modal -->
-<div class="modal fade" id="agentModal" tabindex="-1" aria-labelledby="agentModalLabel" aria-hidden="true">
+<div class="modal fade" id="agentModal" tabindex="-1" aria-labelledby="agentModalLabel" aria-hidden="true" data-bwignore="true" data-1p-ignore="true" data-lpignore="true" autocomplete="off">
   <div class="modal-dialog modal-lg">
     <div class="modal-content">
       <div class="modal-header flex-wrap gap-2 align-items-center justify-content-between">
diff --git a/application/single_app/templates/_multiendpoint_modal.html b/application/single_app/templates/_multiendpoint_modal.html
index c505dd6d..3c41dee2 100644
--- a/application/single_app/templates/_multiendpoint_modal.html
+++ b/application/single_app/templates/_multiendpoint_modal.html
@@ -1,5 +1,5 @@
 <!-- Model Endpoint Modal -->
-<div class="modal fade" id="modelEndpointModal" tabindex="-1" aria-labelledby="modelEndpointModalLabel" aria-hidden="true">
+<div class="modal fade" id="modelEndpointModal" tabindex="-1" aria-labelledby="modelEndpointModalLabel" aria-hidden="true" data-bwignore="true" data-1p-ignore="true" data-lpignore="true" autocomplete="off">
     <div class="modal-dialog modal-xl modal-dialog-scrollable">
         <div class="modal-content">
             <div class="modal-header">
@@ -99,11 +99,11 @@ <h5 class="modal-title" id="modelEndpointModalLabel">Model Endpoint</h5>
                     </div>
                     <div class="col-md-4" id="model-endpoint-secret-group">
                         <label for="model-endpoint-client-secret" class="form-label">Client Secret</label>
-                        <input type="password" class="form-control" id="model-endpoint-client-secret" />
+                        <input type="password" class="form-control" id="model-endpoint-client-secret" autocomplete="new-password" data-bwignore="true" data-1p-ignore="true" data-lpignore="true" />
                     </div>
                     <div class="col-md-6" id="model-endpoint-key-group">
                         <label for="model-endpoint-api-key" class="form-label">API Key</label>
-                        <input type="password" class="form-control" id="model-endpoint-api-key" />
+                        <input type="password" class="form-control" id="model-endpoint-api-key" autocomplete="new-password" data-bwignore="true" data-1p-ignore="true" data-lpignore="true" />
                     </div>
                 </div>
 
diff --git a/application/single_app/templates/chats.html b/application/single_app/templates/chats.html
index 559ca949..4a55acc5 100644
--- a/application/single_app/templates/chats.html
+++ b/application/single_app/templates/chats.html
@@ -1133,39 +1133,39 @@ <h5 class="modal-title" id="scopeLockModalLabel">
 {% block scripts %}
 <script>
     // Ensure global variables are still accessible if needed by older scripts
-    window.enableUserFeedback = "{{ enable_user_feedback }}";
-    window.activeGroupId = "{{ active_group_id }}";
-    window.activeGroupName = "{{ active_group_name }}";
-    window.activePublicWorkspaceId = "{{ active_public_workspace_id }}";
-    window.userGroups = JSON.parse('{{ user_groups|tojson|safe }}');
-    window.userVisiblePublicWorkspaces = JSON.parse('{{ user_visible_public_workspaces|tojson|safe }}');
-    window.chatPromptOptions = JSON.parse('{{ chat_prompt_options|tojson|safe }}');
-    window.chatAgentOptions = JSON.parse('{{ chat_agent_options|tojson|safe }}');
-    window.chatModelOptions = JSON.parse('{{ chat_model_options|tojson|safe }}');
-    window.enableEnhancedCitations = "{{ enable_enhanced_citations }}";
-    window.enable_document_classification = "{{ enable_document_classification }}";
-    window.classification_categories = JSON.parse('{{ settings.document_classification_categories|tojson(indent=None)|safe }}' || '[]');
+    window.enableUserFeedback = {{ enable_user_feedback|tojson }};
+    window.activeGroupId = {{ active_group_id|tojson }};
+    window.activeGroupName = {{ active_group_name|tojson }};
+    window.activePublicWorkspaceId = {{ active_public_workspace_id|tojson }};
+    window.userGroups = {{ user_groups|default([], true)|tojson|safe }};
+    window.userVisiblePublicWorkspaces = {{ user_visible_public_workspaces|default([], true)|tojson|safe }};
+    window.chatPromptOptions = {{ chat_prompt_options|default([], true)|tojson|safe }};
+    window.chatAgentOptions = {{ chat_agent_options|default([], true)|tojson|safe }};
+    window.chatModelOptions = {{ chat_model_options|default([], true)|tojson|safe }};
+    window.enableEnhancedCitations = {{ enable_enhanced_citations|tojson }};
+    window.enable_document_classification = {{ enable_document_classification|tojson }};
+    window.classification_categories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};
     if (!Array.isArray(window.classification_categories)) {
         window.classification_categories = [];
     }
 
     // Current user information for message masking
     window.currentUser = {
-        id: "{{ user_id }}",
-        display_name: "{{ user_display_name }}"
+        id: {{ user_id|tojson }},
+        display_name: {{ user_display_name|tojson }}
     };
 
     // App settings for feature detection
     window.appSettings = {
-        enable_text_to_speech: JSON.parse('{{ 'true' if app_settings.enable_text_to_speech else 'false' }}'),
-        enable_speech_to_text_input: JSON.parse('{{ 'true' if app_settings.enable_speech_to_text_input else 'false' }}'),
-        enable_web_search_user_notice: JSON.parse('{{ 'true' if settings.enable_web_search_user_notice else 'false' }}'),
-        enforce_workspace_scope_lock: JSON.parse('{{ 'true' if settings.enforce_workspace_scope_lock else 'false' }}'),
-        enable_multi_model_endpoints: JSON.parse('{{ 'true' if enable_multi_model_endpoints else 'false' }}'),
-        enable_thoughts: JSON.parse('{{ 'true' if settings.enable_thoughts else 'false' }}')
+        enable_text_to_speech: {{ app_settings.enable_text_to_speech|tojson }},
+        enable_speech_to_text_input: {{ app_settings.enable_speech_to_text_input|tojson }},
+        enable_web_search_user_notice: {{ settings.enable_web_search_user_notice|tojson }},
+        enforce_workspace_scope_lock: {{ settings.enforce_workspace_scope_lock|tojson }},
+        enable_multi_model_endpoints: {{ enable_multi_model_endpoints|tojson }},
+        enable_thoughts: {{ settings.enable_thoughts|tojson }}
     };
 
-    window.multiEndpointNotice = JSON.parse('{{ multi_endpoint_notice_data|tojson()|safe }}');
+    window.multiEndpointNotice = {{ multi_endpoint_notice_data|tojson|safe }};
 
     // Layout related globals (can stay here or move entirely into chat-layout.js if preferred)
     let splitInstance = null;
diff --git a/application/single_app/templates/group_workspaces.html b/application/single_app/templates/group_workspaces.html
index 7a13cf75..ab0a5743 100644
--- a/application/single_app/templates/group_workspaces.html
+++ b/application/single_app/templates/group_workspaces.html
@@ -233,14 +233,14 @@ <h2>Group Workspace</h2>
         </button>
         <div class="dropdown-menu w-100" id="group-dropdown-menu">
           <div class="px-2 group-search-container d-none">
-            <input type="text" class="form-control form-control-sm mb-2" placeholder="Search groups..." id="group-search-input">
+            <input type="text" class="form-control form-control-sm mb-2" placeholder="Search groups..." id="group-search-input" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
           </div>
           <div class="dropdown-items-container" id="group-dropdown-items" style="max-height: 300px; overflow-y: auto;">
             <!-- Groups will be populated here -->
           </div>
         </div>
         <!-- Hidden select element for compatibility -->
-        <select class="d-none" id="group-select"></select>
+        <select class="d-none" id="group-select" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"></select>
       </div>
     </div>
     <div class="col-sm-6">
@@ -1043,9 +1043,9 @@ <h5 class="modal-title" id="item-view-modal-title">View Item</h5>
 </div>
 
 <!-- Modal for Group Prompt Create/Edit (Keep As Is) -->
-<div class="modal fade" id="groupPromptModal" tabindex="-1" aria-hidden="true">
+<div class="modal fade" id="groupPromptModal" tabindex="-1" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog modal-xl" style="max-width: 80%">
-    <form id="group-prompt-form">
+    <form id="group-prompt-form" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
       <div class="modal-content">
         <div class="modal-header">
           <h5 class="modal-title" id="groupPromptModalLabel">
@@ -1068,6 +1068,10 @@ <h5 class="modal-title" id="groupPromptModalLabel">
               type="text"
               class="form-control"
               id="group-prompt-name"
+              autocomplete="off"
+              data-lpignore="true"
+              data-1p-ignore="true"
+              data-bwignore="true"
               required
             />
           </div>
@@ -1079,6 +1083,10 @@ <h5 class="modal-title" id="groupPromptModalLabel">
               class="form-control"
               id="group-prompt-content"
               name="group_prompt_content"
+              autocomplete="off"
+              data-lpignore="true"
+              data-1p-ignore="true"
+              data-bwignore="true"
               rows="10"
             ></textarea>
           </div>
@@ -1104,9 +1112,13 @@ <h5 class="modal-title" id="groupPromptModalLabel">
   tabindex="-1"
   aria-labelledby="docMetadataModalLabel"
   aria-hidden="true"
+  autocomplete="off"
+  data-lpignore="true"
+  data-1p-ignore="true"
+  data-bwignore="true"
 >
   <div class="modal-dialog">
-    <form id="doc-metadata-form">
+    <form id="doc-metadata-form" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
       <div class="modal-content">
         <div class="modal-header">
           <h5 class="modal-title" id="docMetadataModalLabel">
@@ -1128,7 +1140,7 @@ <h5 class="modal-title" id="docMetadataModalLabel">
             <label for="doc-classification" class="form-label"
               >Classification</label
             >
-            <select class="form-select" id="doc-classification">
+            <select class="form-select" id="doc-classification" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
               <option value="">-- Select Classification --</option>
               <option value="none">(No Classification)</option>
               {% for cat in settings.document_classification_categories %}
@@ -1140,7 +1152,7 @@ <h5 class="modal-title" id="docMetadataModalLabel">
           <!-- Title -->
           <div class="mb-3">
             <label for="doc-title" class="form-label">Title</label
-            ><input type="text" class="form-control" id="doc-title" />
+            ><input type="text" class="form-control" id="doc-title" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true" />
           </div>
           <!-- Abstract -->
           <div class="mb-3">
@@ -1148,6 +1160,10 @@ <h5 class="modal-title" id="docMetadataModalLabel">
             ><textarea
               class="form-control"
               id="doc-abstract"
+              autocomplete="off"
+              data-lpignore="true"
+              data-1p-ignore="true"
+              data-bwignore="true"
               rows="3"
             ></textarea>
           </div>
@@ -1155,7 +1171,7 @@ <h5 class="modal-title" id="docMetadataModalLabel">
           <div class="mb-3">
             <label for="doc-keywords" class="form-label"
               >Keywords (comma separated)</label
-            ><input type="text" class="form-control" id="doc-keywords" />
+            ><input type="text" class="form-control" id="doc-keywords" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true" />
           </div>
           <!-- Publication Date -->
           <div class="mb-3">
@@ -1165,6 +1181,10 @@ <h5 class="modal-title" id="docMetadataModalLabel">
               type="text"
               class="form-control"
               id="doc-publication-date"
+              autocomplete="off"
+              data-lpignore="true"
+              data-1p-ignore="true"
+              data-bwignore="true"
               placeholder="e.g. 08/2005 or YYYY-MM-DD"
             />
           </div>
@@ -1172,7 +1192,7 @@ <h5 class="modal-title" id="docMetadataModalLabel">
           <div class="mb-3">
             <label for="doc-authors" class="form-label"
               >Authors (comma separated)</label
-            ><input type="text" class="form-control" id="doc-authors" />
+            ><input type="text" class="form-control" id="doc-authors" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true" />
           </div>
           <!-- Tags -->
           <div class="mb-3">
@@ -1210,9 +1230,9 @@ <h5 class="modal-title" id="docMetadataModalLabel">
 {% endif %}
 
 <!-- Group Share Document Modal -->
-<div class="modal fade" id="groupShareDocumentModal" tabindex="-1" aria-hidden="true">
+<div class="modal fade" id="groupShareDocumentModal" tabindex="-1" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog">
-    <form id="groupShareDocumentForm">
+    <form id="groupShareDocumentForm" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
       <div class="modal-content">
         <div class="modal-header">
           <h5 class="modal-title">Share Document with Groups</h5>
@@ -1249,6 +1269,10 @@ <h6>Currently Shared With:</h6>
               type="text"
               class="form-control"
               id="groupSearchTerm"
+              autocomplete="off"
+              data-lpignore="true"
+              data-1p-ignore="true"
+              data-bwignore="true"
               placeholder="Enter group name..."
             />
             <button
@@ -1295,7 +1319,7 @@ <h6>Currently Shared With:</h6>
   </div>
 </div>
 <!-- Bulk Tag Assignment Modal (Group) -->
-<div class="modal fade" id="groupBulkTagModal" tabindex="-1" aria-labelledby="groupBulkTagModalLabel" aria-hidden="true">
+<div class="modal fade" id="groupBulkTagModal" tabindex="-1" aria-labelledby="groupBulkTagModalLabel" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog modal-lg">
     <div class="modal-content">
       <div class="modal-header">
@@ -1311,7 +1335,7 @@ <h5 class="modal-title" id="groupBulkTagModalLabel">
         </div>
         <div class="mb-3">
           <label for="group-bulk-tag-action" class="form-label fw-bold">Action</label>
-          <select class="form-select" id="group-bulk-tag-action">
+          <select class="form-select" id="group-bulk-tag-action" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
             <option value="add_tags">Add Tags (append to existing)</option>
             <option value="remove_tags">Remove Tags (remove specific tags)</option>
             <option value="set_tags">Replace All Tags (overwrite existing)</option>
@@ -1346,7 +1370,7 @@ <h5 class="modal-title" id="groupBulkTagModalLabel">
 </div>
 
 <!-- Group Tag Management Modal -->
-<div class="modal fade" id="groupTagManagementModal" tabindex="-1" aria-labelledby="groupTagManagementModalLabel" aria-hidden="true">
+<div class="modal fade" id="groupTagManagementModal" tabindex="-1" aria-labelledby="groupTagManagementModalLabel" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog modal-lg">
     <div class="modal-content">
       <div class="modal-header">
@@ -1363,13 +1387,13 @@ <h6 class="card-title d-inline-block" id="group-tag-form-title">Add New Tag</h6>
             </button>
             <div class="row g-2">
               <div class="col-md-6">
-                <input type="text" class="form-control" id="group-new-tag-name" placeholder="Tag name (lowercase, alphanumeric)" maxlength="50">
+                <input type="text" class="form-control" id="group-new-tag-name" placeholder="Tag name (lowercase, alphanumeric)" maxlength="50" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
                 <div class="form-text">Use lowercase letters, numbers, hyphens, underscores</div>
               </div>
               <div class="col-md-4">
                 <div class="input-group">
                   <span class="input-group-text">Color</span>
-                  <input type="color" class="form-control form-control-color" id="group-new-tag-color" value="#0d6efd">
+                  <input type="color" class="form-control form-control-color" id="group-new-tag-color" value="#0d6efd" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
                 </div>
               </div>
               <div class="col-md-2">
@@ -1410,7 +1434,7 @@ <h6 class="card-title">Existing Tags</h6>
 </div>
 
 <!-- Group Tag Selection Modal -->
-<div class="modal fade" id="groupTagSelectionModal" tabindex="-1" aria-labelledby="groupTagSelectionModalLabel" aria-hidden="true">
+<div class="modal fade" id="groupTagSelectionModal" tabindex="-1" aria-labelledby="groupTagSelectionModalLabel" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog">
     <div class="modal-content">
       <div class="modal-header">
@@ -1473,8 +1497,69 @@ <h5 class="modal-title" id="groupTagSelectionModalLabel">Select Tags</h5>
 
 <script>
   window.current_user_id = "{{ session.get('user', {}).get('oid', '') }}";
+
+  function applyGroupWorkspaceAutofillMetadata(root) {
+    if (!root) {
+      return;
+    }
+
+    if (!root.hasAttribute("autocomplete")) {
+      root.setAttribute("autocomplete", "off");
+    }
+
+    if (!root.hasAttribute("data-lpignore")) {
+      root.setAttribute("data-lpignore", "true");
+    }
+
+    if (!root.hasAttribute("data-1p-ignore")) {
+      root.setAttribute("data-1p-ignore", "true");
+    }
+
+    if (!root.hasAttribute("data-bwignore")) {
+      root.setAttribute("data-bwignore", "true");
+    }
+
+    root.querySelectorAll("input, select, textarea").forEach((field) => {
+      const autocompleteValue = field.getAttribute("type") === "password" ? "new-password" : "off";
+
+      if (!field.hasAttribute("autocomplete")) {
+        field.setAttribute("autocomplete", autocompleteValue);
+      }
+
+      if (!field.hasAttribute("data-lpignore")) {
+        field.setAttribute("data-lpignore", "true");
+      }
+
+      if (!field.hasAttribute("data-1p-ignore")) {
+        field.setAttribute("data-1p-ignore", "true");
+      }
+
+      if (!field.hasAttribute("data-bwignore")) {
+        field.setAttribute("data-bwignore", "true");
+      }
+    });
+  }
+
+  function setupGroupWorkspaceAutofillMetadata() {
+    [
+      document.getElementById("group-dropdown"),
+      document.getElementById("groupWorkspaceTabContent"),
+      document.getElementById("groupPromptModal"),
+      document.getElementById("docMetadataModal"),
+      document.getElementById("groupShareDocumentModal"),
+      document.getElementById("groupBulkTagModal"),
+      document.getElementById("groupTagManagementModal"),
+      document.getElementById("groupTagSelectionModal"),
+      document.getElementById("modelEndpointModal"),
+      document.getElementById("agentModal"),
+      document.getElementById("plugin-modal")
+    ].forEach(applyGroupWorkspaceAutofillMetadata);
+  }
+
   // --- Filter toggle button logic ---
   document.addEventListener("DOMContentLoaded", function() {
+    setupGroupWorkspaceAutofillMetadata();
+
     // Group Documents tab
     var docsToggleBtn = document.getElementById("group-docs-filters-toggle-btn");
     var docsCollapse = document.getElementById("group-docs-filters-collapse");
diff --git a/application/single_app/templates/workspace.html b/application/single_app/templates/workspace.html
index 6a46f0af..c216901f 100644
--- a/application/single_app/templates/workspace.html
+++ b/application/single_app/templates/workspace.html
@@ -1032,9 +1032,13 @@ <h5 class="modal-title" id="item-view-modal-label">Details</h5>
     tabindex="-1"
     aria-labelledby="promptModalLabel"
     aria-hidden="true"
+    autocomplete="off"
+    data-lpignore="true"
+    data-1p-ignore="true"
+    data-bwignore="true"
   >
     <div class="modal-dialog modal-xl" style="max-width: 80%">
-      <form id="prompt-form">
+      <form id="prompt-form" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
         <div class="modal-content">
           <div class="modal-header">
             <h5 class="modal-title" id="promptModalLabel">Create Prompt</h5>
@@ -1086,9 +1090,13 @@ <h5 class="modal-title" id="promptModalLabel">Create Prompt</h5>
     tabindex="-1"
     aria-labelledby="docMetadataModalLabel"
     aria-hidden="true"
+    autocomplete="off"
+    data-lpignore="true"
+    data-1p-ignore="true"
+    data-bwignore="true"
   >
     <div class="modal-dialog">
-      <form id="doc-metadata-form">
+      <form id="doc-metadata-form" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
         <div class="modal-content">
           <div class="modal-header">
             <h5 class="modal-title" id="docMetadataModalLabel">
@@ -1199,7 +1207,7 @@ <h5 class="modal-title" id="docMetadataModalLabel">
   </div>
 
 <!-- Bulk Tag Assignment Modal -->
-<div class="modal fade" id="bulkTagModal" tabindex="-1" aria-labelledby="bulkTagModalLabel" aria-hidden="true">
+<div class="modal fade" id="bulkTagModal" tabindex="-1" aria-labelledby="bulkTagModalLabel" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog modal-lg">
     <div class="modal-content">
       <div class="modal-header">
@@ -1259,7 +1267,7 @@ <h5 class="modal-title" id="bulkTagModalLabel">
 </div>
 
 <!-- Tag Management Modal (Shared by both bulk and individual) -->
-<div class="modal fade" id="tagManagementModal" tabindex="-1" aria-labelledby="tagManagementModalLabel" aria-hidden="true">
+<div class="modal fade" id="tagManagementModal" tabindex="-1" aria-labelledby="tagManagementModalLabel" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog modal-lg">
     <div class="modal-content">
       <div class="modal-header">
@@ -1352,7 +1360,7 @@ <h5 class="modal-title" id="deleteTagConfirmModalLabel">
 </div>
 
 <!-- Tag Selection Modal (for selecting from existing tags) -->
-<div class="modal fade" id="tagSelectionModal" tabindex="-1" aria-labelledby="tagSelectionModalLabel" aria-hidden="true">
+<div class="modal fade" id="tagSelectionModal" tabindex="-1" aria-labelledby="tagSelectionModalLabel" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog">
     <div class="modal-content">
       <div class="modal-header">
@@ -1383,9 +1391,9 @@ <h5 class="modal-title" id="tagSelectionModalLabel">Select Tags</h5>
 </div>
 
 <!-- Share Document Modal -->
-<div class="modal fade" id="shareDocumentModal" tabindex="-1" aria-hidden="true">
+<div class="modal fade" id="shareDocumentModal" tabindex="-1" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
   <div class="modal-dialog">
-    <form id="shareDocumentForm">
+    <form id="shareDocumentForm" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true">
       <div class="modal-content">
         <div class="modal-header">
           <h5 class="modal-title">Share Document</h5>
@@ -1571,8 +1579,67 @@ <h5 class="modal-title" id="approveSharedModalLabel">Approve Shared Document</h5
     // Pass current user ID for ownership checks
     window.current_user_id = "{{ session.get('user', {}).get('oid', '') }}";
 
+    function applyWorkspaceAutofillMetadata(root) {
+      if (!root) {
+        return;
+      }
+
+      if (!root.hasAttribute("autocomplete")) {
+        root.setAttribute("autocomplete", "off");
+      }
+
+      if (!root.hasAttribute("data-lpignore")) {
+        root.setAttribute("data-lpignore", "true");
+      }
+
+      if (!root.hasAttribute("data-1p-ignore")) {
+        root.setAttribute("data-1p-ignore", "true");
+      }
+
+      if (!root.hasAttribute("data-bwignore")) {
+        root.setAttribute("data-bwignore", "true");
+      }
+
+      root.querySelectorAll("input, select, textarea").forEach((field) => {
+        const autocompleteValue = field.getAttribute("type") === "password" ? "new-password" : "off";
+
+        if (!field.hasAttribute("autocomplete")) {
+          field.setAttribute("autocomplete", autocompleteValue);
+        }
+
+        if (!field.hasAttribute("data-lpignore")) {
+          field.setAttribute("data-lpignore", "true");
+        }
+
+        if (!field.hasAttribute("data-1p-ignore")) {
+          field.setAttribute("data-1p-ignore", "true");
+        }
+
+        if (!field.hasAttribute("data-bwignore")) {
+          field.setAttribute("data-bwignore", "true");
+        }
+      });
+    }
+
+    function setupWorkspaceAutofillMetadata() {
+      [
+        document.getElementById("workspaceTabContent"),
+        document.getElementById("promptModal"),
+        document.getElementById("docMetadataModal"),
+        document.getElementById("bulkTagModal"),
+        document.getElementById("tagManagementModal"),
+        document.getElementById("tagSelectionModal"),
+        document.getElementById("shareDocumentModal"),
+        document.getElementById("modelEndpointModal"),
+        document.getElementById("agentModal"),
+        document.getElementById("plugin-modal")
+      ].forEach(applyWorkspaceAutofillMetadata);
+    }
+
     // --- Filter toggle button logic ---
     document.addEventListener("DOMContentLoaded", function() {
+      setupWorkspaceAutofillMetadata();
+
       // Documents tab
       var docsToggleBtn = document.getElementById("docs-filters-toggle-btn");
       var docsCollapse = document.getElementById("docs-filters-collapse");
diff --git a/docs/explanation/fixes/CHAT_LEGACY_MODEL_SELECTION_RESTORE_FIX.md b/docs/explanation/fixes/CHAT_LEGACY_MODEL_SELECTION_RESTORE_FIX.md
new file mode 100644
index 00000000..080b4e14
--- /dev/null
+++ b/docs/explanation/fixes/CHAT_LEGACY_MODEL_SELECTION_RESTORE_FIX.md
@@ -0,0 +1,43 @@
+# Chat Legacy Model Selection Restore Fix
+
+Fixed/Implemented in version: **0.240.010**
+
+## Issue Description
+
+The chats page could save a user's preferred legacy GPT deployment to user settings, but returning to the chats page reset the visible model selector back to the first configured model instead of restoring the saved selection.
+
+## Root Cause Analysis
+
+- The chat startup flow still loaded `preferredModelDeployment` from user settings and passed it into the shared model selector.
+- The shared selector returned early whenever multi-endpoint mode was disabled.
+- That early return refreshed the searchable selector UI without first applying the saved legacy deployment value to the hidden `#model-select` element.
+
+## Technical Details
+
+### Files Modified
+
+- `application/single_app/static/js/chat/chat-model-selector.js`
+- `functional_tests/test_reasoning_effort_initial_sync.py`
+- `application/single_app/config.py`
+
+### Code Changes Summary
+
+- Added a legacy-only restore helper in the shared chat model selector to apply `preferredModelDeployment` before refreshing the searchable selector UI.
+- Left the multi-endpoint selection-key logic unchanged.
+- Updated the focused startup regression test to verify the shared selector now restores legacy deployments before reasoning initialization.
+
+### Testing Approach
+
+- Functional regression: `functional_tests/test_reasoning_effort_initial_sync.py`
+
+## Validation
+
+### Before
+
+- Legacy chats saved the preferred deployment successfully.
+- Reloading or returning to the chats page showed the first configured model instead of the saved one.
+
+### After
+
+- Legacy chats restore the saved preferred deployment through the shared selector logic before the selector UI refreshes.
+- The multi-endpoint restore path remains untouched.
\ No newline at end of file
diff --git a/docs/explanation/fixes/CHAT_TEMPLATE_JSON_BOOTSTRAP_FIX.md b/docs/explanation/fixes/CHAT_TEMPLATE_JSON_BOOTSTRAP_FIX.md
new file mode 100644
index 00000000..7e34641b
--- /dev/null
+++ b/docs/explanation/fixes/CHAT_TEMPLATE_JSON_BOOTSTRAP_FIX.md
@@ -0,0 +1,49 @@
+# Chat Template JSON Bootstrap Fix
+
+Fixed/Implemented in version: **0.240.008**
+
+## Issue Description
+
+The chats page could fail during initial load with a browser error similar to `Bad control character in string literal in JSON` when bootstrapped template data included escaped control characters such as newlines.
+
+## Root Cause Analysis
+
+- The template was serializing several server-side objects with `tojson`, wrapping that JSON in a JavaScript string literal, and then calling `JSON.parse(...)` on the client.
+- JavaScript unescaped sequences like `\n` while building the string literal, which turned valid JSON text into invalid JSON content before `JSON.parse(...)` ran.
+- The same bootstrap block also interpolated several string globals directly into JavaScript string literals, which left them vulnerable to the same class of quoting and control-character failures.
+
+## Technical Details
+
+### Files Modified
+
+- `application/single_app/templates/chats.html`
+- `application/single_app/config.py`
+- `functional_tests/test_chat_multi_endpoint_notice_template_fallback.py`
+- `functional_tests/test_chat_template_json_bootstrap_safety.py`
+- `ui_tests/test_chat_page_multi_endpoint_notice_render.py`
+
+### Code Changes Summary
+
+- Replaced `JSON.parse('...{{ value|tojson }}...')` bootstrapping in `chats.html` with direct JavaScript literal assignment using `tojson`.
+- Converted adjacent inline string and boolean globals in the same script block to `tojson` output so user-controlled values cannot break the page bootstrap.
+- Updated the existing multi-endpoint notice regression test to assert the new safe bootstrap pattern.
+- Added a dedicated functional regression test to prevent reintroduction of `JSON.parse`-wrapped Jinja payloads in the chat template.
+- Extended the chat page UI smoke test to fail on browser-side syntax and JSON bootstrap errors.
+
+### Testing Approach
+
+- Functional regression: `functional_tests/test_chat_multi_endpoint_notice_template_fallback.py`
+- Functional regression: `functional_tests/test_chat_template_json_bootstrap_safety.py`
+- UI regression: `ui_tests/test_chat_page_multi_endpoint_notice_render.py`
+
+## Validation
+
+### Before
+
+- Selecting workspace/chat context that introduced escaped control characters into bootstrapped template data could stop the chats page from finishing its JavaScript initialization.
+
+### After
+
+- The chats page bootstraps server-side data as direct JavaScript literals.
+- Escaped control characters remain safely encoded within the serialized objects instead of being reinterpreted by a JavaScript string literal.
+- The page can load without the `Bad control character in string literal in JSON` console failure.
\ No newline at end of file
diff --git a/docs/explanation/fixes/GROUP_WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md b/docs/explanation/fixes/GROUP_WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md
new file mode 100644
index 00000000..846680bc
--- /dev/null
+++ b/docs/explanation/fixes/GROUP_WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md
@@ -0,0 +1,29 @@
+# Group Workspace Autofill Overlay Metadata Fix (v0.240.007)
+
+## Issue Description
+Opening the group workspace could trigger browser autofill overlay errors in the console because the page renders hidden prompt, metadata, sharing, tag-management, and shared endpoint controls on load.
+
+## Root Cause Analysis
+The group workspace template still exposed multiple non-login text, select, and textarea controls without explicit `autocomplete` metadata or password-manager ignore markers. Some autofill overlays inspected those controls together with the shared endpoint secret fields and hit a null autocomplete assumption while classifying them.
+
+## Version Implemented
+Fixed/Implemented in version: **0.240.007**
+
+## Technical Details
+- Files modified:
+  - `application/single_app/templates/group_workspaces.html`
+  - `application/single_app/config.py`
+  - `functional_tests/test_group_workspace_autofill_overlay_metadata.py`
+  - `ui_tests/test_group_workspace_page_autofill_metadata.py`
+- Code changes summary:
+  - Added explicit autofill-ignore metadata to the group selector search field, group prompt form, group document metadata form, group share form, and group tag-management controls rendered at page load.
+  - Added a group-workspace normalization helper that stamps `autocomplete` and common password-manager ignore attributes onto group page controls and hidden modal fields at startup.
+  - Added focused functional and UI regression tests for the group workspace autofill markers.
+  - Bumped the application version to `0.240.007`.
+- Testing approach:
+  - Run the focused group workspace autofill functional test.
+  - Run the group workspace UI metadata test when an authenticated UI environment is available.
+
+## Validation
+- Before: opening the group workspace could still surface autofill overlay null-reference errors when extensions inspected hidden group workspace controls.
+- After: the group workspace page exposes explicit non-login autofill metadata across its load-time controls, reducing extension-side crashes during page analysis.
\ No newline at end of file
diff --git a/docs/explanation/fixes/TABULAR_MULTISHEET_ENTITY_LOOKUP_RELIABILITY_FIX.md b/docs/explanation/fixes/TABULAR_MULTISHEET_ENTITY_LOOKUP_RELIABILITY_FIX.md
new file mode 100644
index 00000000..213f34f3
--- /dev/null
+++ b/docs/explanation/fixes/TABULAR_MULTISHEET_ENTITY_LOOKUP_RELIABILITY_FIX.md
@@ -0,0 +1,52 @@
+# Tabular Multi-Sheet Entity Lookup Reliability Fix (v0.240.009)
+
+Fixed/Implemented in version: **0.240.009**
+
+## Issue Description
+
+Multi-sheet Excel workbooks could intermittently fail during tabular chat analysis even though the workbook was loaded successfully from blob storage and the tabular plugin was enabled. In the failing path, the mini Semantic Kernel tabular pass returned narrative-only retries without invoking analytical tools, so the outer chat flow fell back to schema-only context instead of computed results.
+
+## Root Cause Analysis
+
+- Legacy single-endpoint mode was not the blocker. The logs showed the application loading the legacy Azure OpenAI client, initializing the tabular plugin, and pre-loading workbook sheets successfully.
+- The brittle path was specific to `entity_lookup` orchestration for multi-sheet workbooks. The prompt required explicit `sheet_name` guidance too early, before the model had identified the right starting worksheet or used the plugin's existing cross-sheet discovery capabilities.
+- Sheet ranking for entity lookups could overvalue downstream record sheets such as `Notices` or `Audits` instead of the primary entity worksheet such as `Taxpayers`, which made the first analytical step less obvious.
+- For analytical queries, unsupported `query_tabular_data` expressions on multi-sheet workbooks could collapse into a misleading explicit-sheet error instead of returning a direct query-expression failure, making retries less reliable.
+
+## Technical Details
+
+### Files Modified
+
+- `application/single_app/route_backend_chats.py`
+- `application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py`
+- `application/single_app/config.py`
+- `functional_tests/test_tabular_entity_lookup_mode.py`
+- `functional_tests/test_tabular_multisheet_workbook_support.py`
+
+### Code Changes Summary
+
+- Added entity-anchor worksheet scoring so multi-sheet entity lookups prioritize the primary entity worksheet more reliably.
+- Updated the entity-lookup mini-agent prompt to allow an initial cross-sheet `filter_rows` or `query_tabular_data` discovery step when the starting worksheet is unclear.
+- Added prompt guidance to prefer row-retrieval tools before aggregates for entity lookups and to avoid fragile `DataFrame.query()` patterns.
+- Improved cross-sheet `query_tabular_data` error reporting so expressions that fail on every worksheet return a direct query error instead of a misleading sheet-selection message.
+- Added regression coverage for entity-sheet hinting, cross-sheet discovery prompt guidance, and direct multi-sheet query-error reporting.
+
+### Testing Approach
+
+- Functional regression: `functional_tests/test_tabular_entity_lookup_mode.py`
+- Functional regression: `functional_tests/test_tabular_multisheet_workbook_support.py`
+- Functional regression: `functional_tests/test_tabular_retry_sheet_recovery.py`
+
+## Validation
+
+### Before
+
+- Multi-sheet entity lookup questions could pre-load workbook data successfully but still complete the tabular mini-agent pass without any analytical tool calls.
+- Some multi-sheet analytical retries surfaced a sheet-selection error even when the underlying problem was an invalid or unsupported query expression.
+
+### After
+
+- Multi-sheet entity lookup questions have a clearer first discovery step and stronger primary-sheet guidance.
+- Cross-sheet analytical discovery is explicitly supported in the prompt before the follow-up sheet-specific calls.
+- Invalid cross-sheet query expressions return a direct query failure, improving retry quality and reducing misleading multi-sheet errors.
+- The application version in `config.py` was updated from `0.240.008` to `0.240.009` for this fix.
\ No newline at end of file
diff --git a/docs/explanation/fixes/WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md b/docs/explanation/fixes/WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md
new file mode 100644
index 00000000..5faaeebd
--- /dev/null
+++ b/docs/explanation/fixes/WORKSPACE_AUTOFILL_OVERLAY_METADATA_FIX.md
@@ -0,0 +1,32 @@
+# Workspace Autofill Overlay Metadata Fix (v0.240.007)
+
+## Issue Description
+Opening the personal workspace could still trigger browser autofill overlay errors in the console even after the plugin modal hardening. The workspace page renders several hidden modals and builder surfaces up front, and those non-login controls were still exposed to password-manager classification.
+
+## Root Cause Analysis
+The earlier workspace autofill fix only covered the plugin modal's password fields. The main workspace template, the shared model-endpoint modal, and the agent builder still exposed text, email, select, and password controls without consistent autofill-ignore metadata. Some autofill overlays treated those fields like login candidates and hit a null autocomplete assumption while classifying them.
+
+## Version Implemented
+Fixed/Implemented in version: **0.240.007**
+
+## Technical Details
+- Files modified:
+  - `application/single_app/templates/workspace.html`
+  - `application/single_app/templates/_agent_modal.html`
+  - `application/single_app/templates/_multiendpoint_modal.html`
+  - `application/single_app/config.py`
+  - `functional_tests/test_workspace_autofill_overlay_metadata.py`
+  - `ui_tests/test_workspace_page_autofill_metadata.py`
+- Code changes summary:
+  - Added explicit autofill-ignore metadata to the prompt, document metadata, and share-document forms rendered by the workspace page.
+  - Added a workspace-scoped normalization helper that stamps `autocomplete` and common password-manager ignore attributes onto workspace tab fields and modal controls at load time.
+  - Hardened the shared agent modal container and the model-endpoint secret fields with explicit autofill metadata.
+  - Added focused functional and UI regression tests for the workspace autofill markers.
+  - Bumped the application version to `0.240.007`.
+- Testing approach:
+  - Run the focused workspace autofill functional test.
+  - Run the workspace UI metadata test when an authenticated UI environment is available.
+
+## Validation
+- Before: opening the workspace could still surface autofill overlay null-reference errors when the browser inspected hidden workspace controls.
+- After: the workspace page and its shared modals expose explicit non-login autofill metadata, reducing extension-side crashes during page analysis.
\ No newline at end of file
diff --git a/functional_tests/test_chat_multi_endpoint_notice_template_fallback.py b/functional_tests/test_chat_multi_endpoint_notice_template_fallback.py
index c98444a4..91d78631 100644
--- a/functional_tests/test_chat_multi_endpoint_notice_template_fallback.py
+++ b/functional_tests/test_chat_multi_endpoint_notice_template_fallback.py
@@ -1,13 +1,14 @@
 # test_chat_multi_endpoint_notice_template_fallback.py
-#!/usr/bin/env python3
+# test_chat_multi_endpoint_notice_template_fallback.py
 """
 Functional test for chat multi-endpoint notice template fallback.
-Version: 0.240.004
-Implemented in: 0.240.004
+Version: 0.240.008
+Implemented in: 0.240.008
 
 This test ensures the chats template safely defaults the multi-endpoint notice
-context, renders the notice markup only when enabled, and avoids Jinja
-undefined errors when the route does not pass the notice object.
+context, renders the notice markup only when enabled, avoids Jinja
+undefined errors when the route does not pass the notice object, and emits
+the notice bootstrap data without JSON.parse string wrapping.
 """
 
 from pathlib import Path
@@ -23,7 +24,7 @@ def test_chat_multi_endpoint_notice_template_fallback():
     template_content = CHAT_TEMPLATE.read_text(encoding="utf-8")
     config_content = CONFIG_FILE.read_text(encoding="utf-8")
 
-    assert 'VERSION = "0.240.004"' in config_content, "Expected config.py version 0.240.004"
+    assert 'VERSION = "0.240.008"' in config_content, "Expected config.py version 0.240.008"
     assert '{% set multi_endpoint_notice_data = multi_endpoint_notice|default({}) %}' in template_content, (
         "Expected chats.html to define a safe default for multi_endpoint_notice."
     )
@@ -33,9 +34,12 @@ def test_chat_multi_endpoint_notice_template_fallback():
     assert 'id="multi-endpoint-notice"' in template_content, (
         "Expected chats.html to keep the multi-endpoint notice container for chat-onload.js."
     )
-    assert 'window.multiEndpointNotice = JSON.parse(\'{{ multi_endpoint_notice_data|tojson()|safe }}\');' in template_content, (
+    assert 'window.multiEndpointNotice = {{ multi_endpoint_notice_data|tojson|safe }};' in template_content, (
         "Expected chats.html to serialize the safe default notice object for chat-onload.js."
     )
+    assert 'window.multiEndpointNotice = JSON.parse(' not in template_content, (
+        "Expected chats.html to avoid JSON.parse bootstrapping for notice data."
+    )
     assert '<!--\n            {% if multi_endpoint_notice.enabled %}' not in template_content, (
         "Expected chats.html to remove the HTML comment wrapper around active Jinja markup."
     )
diff --git a/functional_tests/test_chat_template_json_bootstrap_safety.py b/functional_tests/test_chat_template_json_bootstrap_safety.py
new file mode 100644
index 00000000..91fcfd38
--- /dev/null
+++ b/functional_tests/test_chat_template_json_bootstrap_safety.py
@@ -0,0 +1,80 @@
+# test_chat_template_json_bootstrap_safety.py
+"""
+Functional test for chat template JSON bootstrap safety.
+Version: 0.240.008
+Implemented in: 0.240.008
+
+This test ensures the chats template emits bootstrapped chat data as direct
+JavaScript literals rather than wrapping Jinja JSON output in JSON.parse
+string literals that can break when payload values contain control characters.
+"""
+
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+CHAT_TEMPLATE = REPO_ROOT / "application" / "single_app" / "templates" / "chats.html"
+CONFIG_FILE = REPO_ROOT / "application" / "single_app" / "config.py"
+
+SAFE_ASSIGNMENTS = [
+    "window.enableUserFeedback = {{ enable_user_feedback|tojson }};",
+    "window.activeGroupId = {{ active_group_id|tojson }};",
+    "window.activeGroupName = {{ active_group_name|tojson }};",
+    "window.activePublicWorkspaceId = {{ active_public_workspace_id|tojson }};",
+    "window.userGroups = {{ user_groups|default([], true)|tojson|safe }};",
+    "window.userVisiblePublicWorkspaces = {{ user_visible_public_workspaces|default([], true)|tojson|safe }};",
+    "window.chatPromptOptions = {{ chat_prompt_options|default([], true)|tojson|safe }};",
+    "window.chatAgentOptions = {{ chat_agent_options|default([], true)|tojson|safe }};",
+    "window.chatModelOptions = {{ chat_model_options|default([], true)|tojson|safe }};",
+    "window.enableEnhancedCitations = {{ enable_enhanced_citations|tojson }};",
+    "window.enable_document_classification = {{ enable_document_classification|tojson }};",
+    "window.classification_categories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};",
+    "id: {{ user_id|tojson }},",
+    "display_name: {{ user_display_name|tojson }}",
+    "enable_text_to_speech: {{ app_settings.enable_text_to_speech|tojson }},",
+    "enable_speech_to_text_input: {{ app_settings.enable_speech_to_text_input|tojson }},",
+    "enable_web_search_user_notice: {{ settings.enable_web_search_user_notice|tojson }},",
+    "enforce_workspace_scope_lock: {{ settings.enforce_workspace_scope_lock|tojson }},",
+    "enable_multi_model_endpoints: {{ enable_multi_model_endpoints|tojson }},",
+    "enable_thoughts: {{ settings.enable_thoughts|tojson }}",
+    "window.multiEndpointNotice = {{ multi_endpoint_notice_data|tojson|safe }};",
+]
+
+UNSAFE_PARSE_SNIPPETS = [
+    "window.userGroups = JSON.parse('{{ user_groups|tojson|safe }}');",
+    "window.userVisiblePublicWorkspaces = JSON.parse('{{ user_visible_public_workspaces|tojson|safe }}');",
+    "window.chatPromptOptions = JSON.parse('{{ chat_prompt_options|tojson|safe }}');",
+    "window.chatAgentOptions = JSON.parse('{{ chat_agent_options|tojson|safe }}');",
+    "window.chatModelOptions = JSON.parse('{{ chat_model_options|tojson|safe }}');",
+    "window.classification_categories = JSON.parse('{{ settings.document_classification_categories|tojson(indent=None)|safe }}' || '[]');",
+    "window.multiEndpointNotice = JSON.parse('{{ multi_endpoint_notice_data|tojson()|safe }}');",
+]
+
+
+def test_chat_template_bootstraps_json_with_direct_literals():
+    """Verify chats.html emits safe direct literals for bootstrapped JSON data."""
+    template_content = CHAT_TEMPLATE.read_text(encoding="utf-8")
+    config_content = CONFIG_FILE.read_text(encoding="utf-8")
+
+    assert 'VERSION = "0.240.008"' in config_content, "Expected config.py version 0.240.008"
+
+    missing_safe_assignments = [
+        snippet for snippet in SAFE_ASSIGNMENTS if snippet not in template_content
+    ]
+    assert not missing_safe_assignments, (
+        "Expected chats.html to bootstrap data with direct tojson literals. "
+        f"Missing: {missing_safe_assignments}"
+    )
+
+    present_unsafe_snippets = [
+        snippet for snippet in UNSAFE_PARSE_SNIPPETS if snippet in template_content
+    ]
+    assert not present_unsafe_snippets, (
+        "Expected chats.html to avoid JSON.parse-wrapped template payloads. "
+        f"Found: {present_unsafe_snippets}"
+    )
+
+
+if __name__ == "__main__":
+    test_chat_template_bootstraps_json_with_direct_literals()
+    print("✅ Chat template JSON bootstrap safety verified.")
\ No newline at end of file
diff --git a/functional_tests/test_group_workspace_autofill_overlay_metadata.py b/functional_tests/test_group_workspace_autofill_overlay_metadata.py
new file mode 100644
index 00000000..3fd8ae22
--- /dev/null
+++ b/functional_tests/test_group_workspace_autofill_overlay_metadata.py
@@ -0,0 +1,69 @@
+# test_group_workspace_autofill_overlay_metadata.py
+"""
+Functional test for group workspace autofill overlay metadata hardening.
+Version: 0.240.007
+Implemented in: 0.240.007
+
+This test ensures the group workspace page exposes explicit autofill metadata so
+browser/password-manager overlays do not treat hidden prompt, metadata,
+sharing, and tag-management controls as login candidates.
+"""
+
+from pathlib import Path
+import sys
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+GROUP_WORKSPACE_TEMPLATE = REPO_ROOT / "application" / "single_app" / "templates" / "group_workspaces.html"
+
+
+def read_text(path: Path) -> str:
+    """Return UTF-8 text for a repository file."""
+    return path.read_text(encoding="utf-8")
+
+
+def test_group_workspace_autofill_overlay_metadata() -> bool:
+    """Verify group workspace template autofill markers and normalization."""
+    print("Testing group workspace autofill overlay metadata hardening...")
+
+    content = read_text(GROUP_WORKSPACE_TEMPLATE)
+
+    required_markers = [
+        'id="group-search-input" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="group-select" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="groupPromptModal" tabindex="-1" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="group-prompt-form" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="group-prompt-name"',
+        'id="group-prompt-content"',
+        'id="groupShareDocumentModal" tabindex="-1" aria-hidden="true" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="groupShareDocumentForm" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="groupSearchTerm"',
+        'id="group-bulk-tag-action" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="group-new-tag-name"',
+        'function applyGroupWorkspaceAutofillMetadata(root) {',
+        'function setupGroupWorkspaceAutofillMetadata() {',
+        'document.getElementById("group-dropdown")',
+        'document.getElementById("groupWorkspaceTabContent")',
+        'document.getElementById("groupPromptModal")',
+        'document.getElementById("groupShareDocumentModal")',
+        'document.getElementById("modelEndpointModal")',
+        'document.getElementById("agentModal")',
+        'document.getElementById("plugin-modal")',
+        'const autocompleteValue = field.getAttribute("type") === "password" ? "new-password" : "off";',
+        'setupGroupWorkspaceAutofillMetadata();'
+    ]
+
+    missing_markers = [marker for marker in required_markers if marker not in content]
+    if missing_markers:
+        print("Missing group workspace autofill hardening markers:")
+        for marker in missing_markers:
+            print(f"  - {marker}")
+        return False
+
+    print("Group workspace autofill overlay metadata hardening test passed!")
+    return True
+
+
+if __name__ == "__main__":
+    success = test_group_workspace_autofill_overlay_metadata()
+    sys.exit(0 if success else 1)
\ No newline at end of file
diff --git a/functional_tests/test_reasoning_effort_initial_sync.py b/functional_tests/test_reasoning_effort_initial_sync.py
index 8023f8e7..347d8ff0 100644
--- a/functional_tests/test_reasoning_effort_initial_sync.py
+++ b/functional_tests/test_reasoning_effort_initial_sync.py
@@ -2,12 +2,13 @@
 # test_reasoning_effort_initial_sync.py
 """
 Functional test for reasoning effort initial state sync.
-Version: 0.239.192
-Implemented in: 0.239.125
+Version: 0.240.010
+Implemented in: 0.240.010
 
-This test ensures that the chat page applies the preferred model before
-initializing reasoning effort state so the reasoning button reflects the saved
-level on first load instead of waiting for a manual change.
+This test ensures that the chat page restores the saved preferred model through
+the shared selector logic before initializing reasoning effort state so the
+reasoning button reflects the saved level on first load instead of waiting for
+a manual change.
 """
 
 import os
@@ -34,6 +35,15 @@
     'chat',
     'chat-onload.js',
 )
+CHAT_MODEL_SELECTOR_FILE = os.path.join(
+    ROOT_DIR,
+    'application',
+    'single_app',
+    'static',
+    'js',
+    'chat',
+    'chat-model-selector.js',
+)
 CONFIG_FILE = os.path.join(
     ROOT_DIR,
     'application',
@@ -77,7 +87,7 @@ def test_reasoning_toggle_uses_applied_startup_settings():
 
 
 def test_chat_onload_sets_model_before_reasoning_initialization():
-    """Verify chat startup applies the preferred model before reasoning init."""
+    """Verify chat startup restores the preferred model before reasoning init."""
     print('🔍 Testing chat onload reasoning initialization order...')
 
     try:
@@ -86,15 +96,18 @@ def test_chat_onload_sets_model_before_reasoning_initialization():
         required_snippets = [
             'const userSettingsPromise = loadUserSettings();',
             'const userSettings = await userSettingsPromise;',
-            'modelSelect.value = userSettings.preferredModelDeployment;',
             'initializeModelSelector();',
+            'await populateModelDropdown({',
+            'preferredModelId,',
+            'preferredModelDeployment,',
+            'preserveCurrentSelection: false,',
             'initializeReasoningToggle(userSettings);',
         ]
 
         missing = [snippet for snippet in required_snippets if snippet not in content]
         assert not missing, f'Missing onload startup ordering logic: {missing}'
 
-        preferred_model_index = content.index('modelSelect.value = userSettings.preferredModelDeployment;')
+        preferred_model_index = content.index('await populateModelDropdown({')
         reasoning_init_index = content.index('initializeReasoningToggle(userSettings);')
         assert preferred_model_index < reasoning_init_index, (
             'Expected preferred model to be applied before reasoning initialization'
@@ -110,13 +123,47 @@ def test_chat_onload_sets_model_before_reasoning_initialization():
         return False
 
 
+def test_model_selector_restores_legacy_preferred_model_before_refresh():
+    """Verify legacy mode restores the saved preferred deployment before refresh."""
+    print('🔍 Testing legacy model restore in shared selector...')
+
+    try:
+        content = read_file(CHAT_MODEL_SELECTOR_FILE)
+
+        required_snippets = [
+            'function restoreLegacyPreferredModelSelection(preferredModelDeployment) {',
+            'const matchingOption = Array.from(modelSelect.options).find(option => (',
+            'option.value === preferredModelDeployment',
+            'modelSelect.value = matchingOption.value;',
+            'restoreLegacyPreferredModelSelection(restoreOptions.preferredModelDeployment || null);',
+        ]
+
+        missing = [snippet for snippet in required_snippets if snippet not in content]
+        assert not missing, f'Missing legacy preferred model restore logic: {missing}'
+
+        restore_index = content.index('restoreLegacyPreferredModelSelection(restoreOptions.preferredModelDeployment || null);')
+        refresh_index = content.index('modelSelectorController?.refresh();')
+        assert restore_index < refresh_index, (
+            'Expected legacy preferred model restoration to occur before the selector refresh'
+        )
+
+        print('✅ Legacy model restore in shared selector passed')
+        return True
+
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
 def test_config_version_bumped_for_reasoning_sync_fix():
     """Verify config version was bumped for the reasoning startup sync fix."""
     print('🔍 Testing config version bump...')
 
     try:
         content = read_file(CONFIG_FILE)
-        assert 'VERSION = "0.239.192"' in content, 'Expected config.py version 0.239.192'
+        assert 'VERSION = "0.240.010"' in content, 'Expected config.py version 0.240.010'
 
         print('✅ Config version bump passed')
         return True
@@ -132,6 +179,7 @@ def test_config_version_bumped_for_reasoning_sync_fix():
     tests = [
         test_reasoning_toggle_uses_applied_startup_settings,
         test_chat_onload_sets_model_before_reasoning_initialization,
+        test_model_selector_restores_legacy_preferred_model_before_refresh,
         test_config_version_bumped_for_reasoning_sync_fix,
     ]
 
diff --git a/functional_tests/test_tabular_entity_lookup_mode.py b/functional_tests/test_tabular_entity_lookup_mode.py
index 576fdebc..990513fb 100644
--- a/functional_tests/test_tabular_entity_lookup_mode.py
+++ b/functional_tests/test_tabular_entity_lookup_mode.py
@@ -2,8 +2,8 @@
 # test_tabular_entity_lookup_mode.py
 """
 Functional test for cross-sheet entity lookup routing fix.
-Version: 0.239.120
-Implemented in: 0.239.119 (entity-lookup routing); 0.239.120 (concrete call example retry)
+Version: 0.240.009
+Implemented in: 0.240.009
 
 This test ensures related-record workbook questions route to entity-lookup
 mode, rank relevant worksheets beyond the first successful sheet, keep the
@@ -33,7 +33,10 @@
     'get_tabular_invocation_selected_sheets',
     '_normalize_tabular_sheet_token',
     '_tokenize_tabular_sheet_text',
+    '_extract_tabular_entity_anchor_terms',
     '_score_tabular_sheet_match',
+    '_score_tabular_entity_sheet_match',
+    '_select_likely_workbook_sheet',
     '_select_relevant_workbook_sheets',
     'is_tabular_access_limited_analysis',
 }
@@ -151,6 +154,70 @@ def test_entity_lookup_sheet_selection_prioritizes_related_worksheets():
         return False
 
 
+def test_entity_lookup_primary_sheet_hint_prefers_anchor_entity_sheet():
+    """Verify entity lookup mode prioritizes the primary entity worksheet."""
+    print('🔍 Testing entity-lookup primary worksheet hinting...')
+
+    try:
+        helpers, route_content = load_tabular_route_helpers()
+        extract_anchor_terms = helpers['_extract_tabular_entity_anchor_terms']
+        score_entity_sheet = helpers['_score_tabular_entity_sheet_match']
+        select_likely_sheet = helpers['_select_likely_workbook_sheet']
+        select_relevant_sheets = helpers['_select_relevant_workbook_sheets']
+
+        entity_lookup_question = (
+            'Find taxpayer TP000123. Show their profile, tax return summary, and '
+            'any related W-2, 1099, payment, refund, notice, audit, or '
+            'installment agreement records.'
+        )
+        per_sheet = {
+            'Taxpayers': {
+                'columns': ['TaxpayerID', 'FirstName', 'LastName', 'Status'],
+            },
+            'TaxReturns': {
+                'columns': ['ReturnID', 'TaxpayerID', 'TaxLiability', 'RefundAmount'],
+            },
+            'Audits': {
+                'columns': ['AuditID', 'TaxpayerID', 'AuditStatus'],
+            },
+            'Notices': {
+                'columns': ['NoticeID', 'TaxpayerID', 'NoticeType'],
+            },
+        }
+        sheet_names = list(per_sheet.keys())
+
+        anchor_terms = extract_anchor_terms(entity_lookup_question)
+        likely_sheet = select_likely_sheet(
+            sheet_names,
+            entity_lookup_question,
+            per_sheet=per_sheet,
+            score_match_fn=score_entity_sheet,
+        )
+        relevant_sheets = select_relevant_sheets(
+            sheet_names,
+            entity_lookup_question,
+            per_sheet=per_sheet,
+            score_match_fn=score_entity_sheet,
+        )
+
+        assert anchor_terms[0] == 'taxpayer', anchor_terms
+        assert 'taxpayer' in anchor_terms, anchor_terms
+        assert likely_sheet == 'Taxpayers', likely_sheet
+        assert relevant_sheets[0] == 'Taxpayers', relevant_sheets
+        assert relevant_sheets.index('Taxpayers') < relevant_sheets.index('Notices'), relevant_sheets
+        assert 'begin with filter_rows or query_tabular_data without sheet_name so the plugin can perform a cross-sheet discovery search' in route_content, route_content
+        assert 'Do not start with aggregate_column, group_by_aggregate, or group_by_datetime_component until you have located the relevant entity rows.' in route_content, route_content
+
+        print('✅ Entity-lookup primary worksheet hinting passed')
+        return True
+
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
 def test_entity_lookup_retry_guardrails_detect_incomplete_successes():
     """Verify one-sheet successes still trigger execution-gap retries."""
     print('🔍 Testing entity-lookup retry guardrails...')
@@ -277,6 +344,7 @@ def test_entity_lookup_missing_sheet_feedback_generates_concrete_examples():
     tests = [
         test_cross_sheet_questions_route_to_entity_lookup_mode,
         test_entity_lookup_sheet_selection_prioritizes_related_worksheets,
+        test_entity_lookup_primary_sheet_hint_prefers_anchor_entity_sheet,
         test_entity_lookup_retry_guardrails_detect_incomplete_successes,
         test_entity_lookup_missing_sheet_feedback_generates_concrete_examples,
     ]
diff --git a/functional_tests/test_tabular_multisheet_workbook_support.py b/functional_tests/test_tabular_multisheet_workbook_support.py
index 9d0ca041..75b389e6 100644
--- a/functional_tests/test_tabular_multisheet_workbook_support.py
+++ b/functional_tests/test_tabular_multisheet_workbook_support.py
@@ -2,8 +2,8 @@
 # test_tabular_multisheet_workbook_support.py
 """
 Functional test for multi-sheet workbook analytical orchestration fix.
-Version: 0.239.124
-Implemented in: 0.239.111
+Version: 0.240.009
+Implemented in: 0.240.009
 
 This test ensures that multi-sheet workbook analysis can select the likely
 worksheet, use lookup_value for row-and-column retrieval, and constrain the
@@ -230,6 +230,7 @@ def test_route_uses_analytical_filters_and_lookup_guidance():
             'analysis function filters are configured': 'included_functions' in route_content,
             'retry attempts require analytical function use': 'FunctionChoiceBehavior.Required(' in route_content,
             'likely sheet override is applied': 'tabular_plugin.set_default_sheet(container, blob_path, likely_sheet)' in route_content,
+            'query syntax guidance is present': 'Avoid method calls such as .str.lower(), .astype(...), or other Python expressions that DataFrame.query() may reject.' in route_content,
         }
 
         failed_checks = [name for name, passed in checks.items() if not passed]
@@ -245,6 +246,37 @@ def test_route_uses_analytical_filters_and_lookup_guidance():
         return False
 
 
+def test_cross_sheet_query_reports_invalid_expression_directly():
+    """Verify invalid cross-sheet query expressions return a direct query error."""
+    print('Testing invalid cross-sheet query feedback...')
+
+    try:
+        plugin, _, _ = build_mock_workbook_plugin()
+        result_json = asyncio.run(plugin.query_tabular_data(
+            user_id='test-user',
+            conversation_id='test-conversation',
+            filename='Family Finances.xlsx',
+            query_expression='Nov-25.astype(float) > 0',
+            source='workspace',
+        ))
+        payload = json.loads(result_json)
+
+        assert 'error' in payload, payload
+        assert 'could not be evaluated on any worksheet during cross-sheet search' in payload['error'], payload
+        assert payload['selected_sheet'] == 'ALL (cross-sheet search)', payload
+        assert 'Specify sheet_name or sheet_index' not in payload['error'], payload
+        assert payload['query_expression'] == 'Nov-25.astype(float) > 0', payload
+
+        print('PASS invalid cross-sheet query feedback')
+        return True
+
+    except Exception as exc:
+        print(f'FAIL test: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
 def test_column_based_scoring_selects_sheet_by_column_names():
     """Verify likely-sheet selection uses column names when sheet names are generic.
 
@@ -353,6 +385,7 @@ def test_fallback_selects_largest_sheet_when_no_column_match():
         test_likely_sheet_helper_handles_pluralized_question_text,
         test_route_uses_analytical_filters_and_lookup_guidance,
         test_column_based_scoring_selects_sheet_by_column_names,
+        test_cross_sheet_query_reports_invalid_expression_directly,
         test_fallback_selects_largest_sheet_when_no_column_match,
     ]
 
diff --git a/functional_tests/test_workspace_autofill_overlay_metadata.py b/functional_tests/test_workspace_autofill_overlay_metadata.py
new file mode 100644
index 00000000..0ae6a085
--- /dev/null
+++ b/functional_tests/test_workspace_autofill_overlay_metadata.py
@@ -0,0 +1,89 @@
+# test_workspace_autofill_overlay_metadata.py
+"""
+Functional test for workspace autofill overlay metadata hardening.
+Version: 0.240.007
+Implemented in: 0.240.007
+
+This test ensures the workspace page and its shared modal includes expose
+explicit autofill metadata so browser/password-manager overlays do not treat
+non-login fields like prompt, sharing, agent, plugin, and endpoint controls as
+login candidates.
+"""
+
+from pathlib import Path
+import sys
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+WORKSPACE_TEMPLATE = REPO_ROOT / "application" / "single_app" / "templates" / "workspace.html"
+AGENT_MODAL_TEMPLATE = REPO_ROOT / "application" / "single_app" / "templates" / "_agent_modal.html"
+MULTIENDPOINT_MODAL_TEMPLATE = REPO_ROOT / "application" / "single_app" / "templates" / "_multiendpoint_modal.html"
+
+
+def read_text(path: Path) -> str:
+    """Return UTF-8 text for a repository file."""
+    return path.read_text(encoding="utf-8")
+
+
+def test_workspace_autofill_overlay_metadata() -> bool:
+    """Verify workspace template normalization and shared modal markers."""
+    print("Testing workspace autofill overlay metadata hardening...")
+
+    workspace_content = read_text(WORKSPACE_TEMPLATE)
+    agent_modal_content = read_text(AGENT_MODAL_TEMPLATE)
+    multiendpoint_content = read_text(MULTIENDPOINT_MODAL_TEMPLATE)
+
+    workspace_markers = [
+        'id="prompt-form" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="doc-metadata-form" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'id="shareDocumentForm" autocomplete="off" data-lpignore="true" data-1p-ignore="true" data-bwignore="true"',
+        'function applyWorkspaceAutofillMetadata(root) {',
+        'function setupWorkspaceAutofillMetadata() {',
+        'document.getElementById("promptModal")',
+        'document.getElementById("shareDocumentModal")',
+        'document.getElementById("modelEndpointModal")',
+        'document.getElementById("agentModal")',
+        'document.getElementById("plugin-modal")',
+        'const autocompleteValue = field.getAttribute("type") === "password" ? "new-password" : "off";',
+        'field.setAttribute("autocomplete", autocompleteValue);',
+        'field.setAttribute("data-lpignore", "true");',
+        'field.setAttribute("data-1p-ignore", "true");',
+        'field.setAttribute("data-bwignore", "true");',
+        'setupWorkspaceAutofillMetadata();'
+    ]
+
+    agent_markers = [
+        'id="agentModal"',
+        'data-bwignore="true"',
+        'data-1p-ignore="true"',
+        'data-lpignore="true"',
+        'autocomplete="off"'
+    ]
+
+    multiendpoint_markers = [
+        'id="modelEndpointModal"',
+        'id="model-endpoint-client-secret" autocomplete="new-password" data-bwignore="true" data-1p-ignore="true" data-lpignore="true"',
+        'id="model-endpoint-api-key" autocomplete="new-password" data-bwignore="true" data-1p-ignore="true" data-lpignore="true"'
+    ]
+
+    missing_workspace_markers = [marker for marker in workspace_markers if marker not in workspace_content]
+    missing_agent_markers = [marker for marker in agent_markers if marker not in agent_modal_content]
+    missing_multiendpoint_markers = [marker for marker in multiendpoint_markers if marker not in multiendpoint_content]
+
+    if missing_workspace_markers or missing_agent_markers or missing_multiendpoint_markers:
+        print("Missing workspace autofill hardening markers:")
+        for marker in missing_workspace_markers:
+            print(f"  - workspace.html: {marker}")
+        for marker in missing_agent_markers:
+            print(f"  - _agent_modal.html: {marker}")
+        for marker in missing_multiendpoint_markers:
+            print(f"  - _multiendpoint_modal.html: {marker}")
+        return False
+
+    print("Workspace autofill overlay metadata hardening test passed!")
+    return True
+
+
+if __name__ == "__main__":
+    success = test_workspace_autofill_overlay_metadata()
+    sys.exit(0 if success else 1)
\ No newline at end of file
diff --git a/ui_tests/test_chat_page_multi_endpoint_notice_render.py b/ui_tests/test_chat_page_multi_endpoint_notice_render.py
index 282578ea..ead0c4ef 100644
--- a/ui_tests/test_chat_page_multi_endpoint_notice_render.py
+++ b/ui_tests/test_chat_page_multi_endpoint_notice_render.py
@@ -1,11 +1,13 @@
 # test_chat_page_multi_endpoint_notice_render.py
+# test_chat_page_multi_endpoint_notice_render.py
 """
 UI test for chat page multi-endpoint notice rendering.
-Version: 0.240.004
-Implemented in: 0.240.004
+Version: 0.240.008
+Implemented in: 0.240.008
 
 This test ensures the authenticated chats page loads successfully and renders
-the primary chat UI without a server-side template failure.
+the primary chat UI without a server-side template failure or a JavaScript
+bootstrap syntax error.
 """
 
 import os
@@ -33,6 +35,18 @@ def test_chat_page_multi_endpoint_notice_render(playwright):
         viewport={"width": 1440, "height": 900},
     )
     page = context.new_page()
+    page_errors = []
+    console_errors = []
+
+    def track_page_error(error):
+        page_errors.append(str(error))
+
+    def track_console(message):
+        if message.type == "error":
+            console_errors.append(message.text)
+
+    page.on("pageerror", track_page_error)
+    page.on("console", track_console)
 
     try:
         response = page.goto(f"{BASE_URL}/chats", wait_until="domcontentloaded")
@@ -42,6 +56,22 @@ def test_chat_page_multi_endpoint_notice_render(playwright):
 
         expect(page.locator("#chatbox")).to_be_visible()
         expect(page.locator("#user-input")).to_be_visible()
+        page.wait_for_load_state("networkidle")
+
+        syntax_errors = [message for message in page_errors if "SyntaxError" in message]
+        bad_control_errors = [
+            message for message in console_errors
+            if "Bad control character" in message or "JSON.parse" in message
+        ]
+
+        assert not syntax_errors, (
+            "Expected /chats to boot without JavaScript syntax errors. "
+            f"Observed: {syntax_errors}"
+        )
+        assert not bad_control_errors, (
+            "Expected /chats to avoid JSON bootstrap parse errors. "
+            f"Observed: {bad_control_errors}"
+        )
     finally:
         context.close()
         browser.close()
diff --git a/ui_tests/test_group_workspace_page_autofill_metadata.py b/ui_tests/test_group_workspace_page_autofill_metadata.py
new file mode 100644
index 00000000..9c84e99c
--- /dev/null
+++ b/ui_tests/test_group_workspace_page_autofill_metadata.py
@@ -0,0 +1,73 @@
+# test_group_workspace_page_autofill_metadata.py
+"""
+UI test for group workspace autofill metadata hardening.
+Version: 0.240.007
+Implemented in: 0.240.007
+
+This test ensures the group workspace page applies autofill ignore metadata to
+its non-login controls that are rendered in hidden modals and page-level group
+selection surfaces.
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+
+BASE_URL = os.getenv("SIMPLECHAT_UI_BASE_URL", "").rstrip("/")
+STORAGE_STATE = os.getenv("SIMPLECHAT_UI_STORAGE_STATE", "")
+
+
+def _require_ui_env():
+    if not BASE_URL:
+        pytest.skip("Set SIMPLECHAT_UI_BASE_URL to run this UI test.")
+    if not STORAGE_STATE or not Path(STORAGE_STATE).exists():
+        pytest.skip("Set SIMPLECHAT_UI_STORAGE_STATE to a valid authenticated Playwright storage state file.")
+
+
+@pytest.mark.ui
+def test_group_workspace_page_autofill_metadata(playwright):
+    """Validate group workspace runtime metadata for non-login fields."""
+    _require_ui_env()
+
+    browser = playwright.chromium.launch()
+    context = browser.new_context(
+        storage_state=STORAGE_STATE,
+        viewport={"width": 1440, "height": 900},
+    )
+    page = context.new_page()
+
+    field_expectations = {
+        "#group-search-input": {"autocomplete": "off", "data-bwignore": "true"},
+        "#group-select": {"autocomplete": "off", "data-bwignore": "true"},
+        "#group-prompt-form": {"autocomplete": "off", "data-bwignore": "true"},
+        "#group-prompt-name": {"autocomplete": "off", "data-bwignore": "true"},
+        "#doc-title": {"autocomplete": "off", "data-bwignore": "true"},
+        "#groupShareDocumentForm": {"autocomplete": "off", "data-bwignore": "true"},
+        "#groupSearchTerm": {"autocomplete": "off", "data-bwignore": "true"},
+        "#group-bulk-tag-action": {"autocomplete": "off", "data-bwignore": "true"},
+        "#group-new-tag-name": {"autocomplete": "off", "data-bwignore": "true"},
+        "#model-endpoint-client-secret": {"autocomplete": "new-password", "data-bwignore": "true"},
+        "#model-endpoint-api-key": {"autocomplete": "new-password", "data-bwignore": "true"},
+    }
+
+    try:
+        response = page.goto(f"{BASE_URL}/group_workspaces", wait_until="networkidle")
+
+        assert response is not None, "Expected a navigation response when loading /group_workspaces."
+        assert response.ok, f"Expected /group_workspaces to load successfully, got HTTP {response.status}."
+        expect(page.locator("#groupWorkspaceTabContent")).to_be_visible()
+
+        for selector, attributes in field_expectations.items():
+            locator = page.locator(selector)
+            expect(locator).to_have_count(1)
+            for attribute_name, expected_value in attributes.items():
+                actual_value = locator.get_attribute(attribute_name)
+                assert actual_value == expected_value, (
+                    f"Expected {selector} to expose {attribute_name}={expected_value!r}, got {actual_value!r}."
+                )
+    finally:
+        context.close()
+        browser.close()
\ No newline at end of file
diff --git a/ui_tests/test_workspace_page_autofill_metadata.py b/ui_tests/test_workspace_page_autofill_metadata.py
new file mode 100644
index 00000000..258f5930
--- /dev/null
+++ b/ui_tests/test_workspace_page_autofill_metadata.py
@@ -0,0 +1,69 @@
+# test_workspace_page_autofill_metadata.py
+"""
+UI test for workspace autofill metadata hardening.
+Version: 0.240.007
+Implemented in: 0.240.007
+
+This test ensures the workspace page applies autofill ignore metadata to the
+non-login controls that are rendered in hidden modals and builder surfaces.
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+
+BASE_URL = os.getenv("SIMPLECHAT_UI_BASE_URL", "").rstrip("/")
+STORAGE_STATE = os.getenv("SIMPLECHAT_UI_STORAGE_STATE", "")
+
+
+def _require_ui_env():
+    if not BASE_URL:
+        pytest.skip("Set SIMPLECHAT_UI_BASE_URL to run this UI test.")
+    if not STORAGE_STATE or not Path(STORAGE_STATE).exists():
+        pytest.skip("Set SIMPLECHAT_UI_STORAGE_STATE to a valid authenticated Playwright storage state file.")
+
+
+@pytest.mark.ui
+def test_workspace_page_autofill_metadata(playwright):
+    """Validate workspace runtime metadata for non-login modal fields."""
+    _require_ui_env()
+
+    browser = playwright.chromium.launch()
+    context = browser.new_context(
+        storage_state=STORAGE_STATE,
+        viewport={"width": 1440, "height": 900},
+    )
+    page = context.new_page()
+
+    field_expectations = {
+        "#prompt-form": {"autocomplete": "off", "data-bwignore": "true"},
+        "#prompt-name": {"autocomplete": "off", "data-bwignore": "true"},
+        "#doc-title": {"autocomplete": "off", "data-bwignore": "true"},
+        "#newUserEmail": {"autocomplete": "off", "data-bwignore": "true"},
+        "#agent-display-name": {"autocomplete": "off", "data-bwignore": "true"},
+        "#plugin-display-name": {"autocomplete": "off", "data-bwignore": "true"},
+        "#model-endpoint-client-secret": {"autocomplete": "new-password", "data-bwignore": "true"},
+        "#model-endpoint-api-key": {"autocomplete": "new-password", "data-bwignore": "true"},
+    }
+
+    try:
+        response = page.goto(f"{BASE_URL}/workspace", wait_until="networkidle")
+
+        assert response is not None, "Expected a navigation response when loading /workspace."
+        assert response.ok, f"Expected /workspace to load successfully, got HTTP {response.status}."
+        expect(page.locator("#documents-tab")).to_be_visible()
+
+        for selector, attributes in field_expectations.items():
+            locator = page.locator(selector)
+            expect(locator).to_have_count(1)
+            for attribute_name, expected_value in attributes.items():
+                actual_value = locator.get_attribute(attribute_name)
+                assert actual_value == expected_value, (
+                    f"Expected {selector} to expose {attribute_name}={expected_value!r}, got {actual_value!r}."
+                )
+    finally:
+        context.close()
+        browser.close()
\ No newline at end of file

From 87799ba8c84a94a0f5344b8923a113fa81f55e3b Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Wed, 1 Apr 2026 10:43:57 -0400
Subject: [PATCH 03/12] fixed entity too large bug for tabular

---
 application/single_app/config.py              |   2 +-
 .../single_app/functions_message_artifacts.py | 415 ++++++++++++++++++
 .../single_app/json_schema_validation.py      |  28 +-
 application/single_app/route_backend_chats.py | 281 ++++++++++--
 .../route_backend_conversation_export.py      |  24 +
 .../single_app/route_backend_conversations.py |  44 ++
 .../single_app/route_backend_plugins.py       |  10 +-
 .../route_frontend_conversations.py           |   3 +
 .../static/js/admin/admin_plugins.js          |  14 +-
 .../static/js/admin/admin_plugins_new.js      |  14 +-
 .../single_app/static/js/plugin_common.js     |  14 +
 .../static/js/workspace/workspace_plugins.js  |  13 +-
 .../js/workspace/workspace_plugins_new.js     |  13 +-
 ...ASSISTANT_CITATION_ARTIFACT_STORAGE_FIX.md |  54 +++
 .../TABULAR_PROMPT_BUDGET_FALLBACK_FIX.md     |  46 ++
 ...PACE_PLUGIN_VALIDATION_AUDIT_FIELDS_FIX.md |  53 +++
 ...est_assistant_citation_artifact_storage.py | 156 +++++++
 ...validation_managed_fields_compatibility.py | 149 +++++++
 .../test_tabular_raw_tool_fallback.py         |  85 +++-
 19 files changed, 1342 insertions(+), 76 deletions(-)
 create mode 100644 application/single_app/functions_message_artifacts.py
 create mode 100644 docs/explanation/fixes/ASSISTANT_CITATION_ARTIFACT_STORAGE_FIX.md
 create mode 100644 docs/explanation/fixes/TABULAR_PROMPT_BUDGET_FALLBACK_FIX.md
 create mode 100644 docs/explanation/fixes/WORKSPACE_PLUGIN_VALIDATION_AUDIT_FIELDS_FIX.md
 create mode 100644 functional_tests/test_assistant_citation_artifact_storage.py
 create mode 100644 functional_tests/test_plugin_validation_managed_fields_compatibility.py

diff --git a/application/single_app/config.py b/application/single_app/config.py
index 0e24fd64..0e55ea15 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.010"
+VERSION = "0.240.013"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/functions_message_artifacts.py b/application/single_app/functions_message_artifacts.py
new file mode 100644
index 00000000..ca2a8edc
--- /dev/null
+++ b/application/single_app/functions_message_artifacts.py
@@ -0,0 +1,415 @@
+# functions_message_artifacts.py
+"""Helpers for storing large assistant-side payloads outside primary chat items."""
+
+import json
+from copy import deepcopy
+from typing import Any, Dict, List, Optional, Tuple
+
+
+ASSISTANT_ARTIFACT_ROLE = 'assistant_artifact'
+ASSISTANT_ARTIFACT_CHUNK_ROLE = 'assistant_artifact_chunk'
+ASSISTANT_ARTIFACT_KIND_AGENT_CITATION = 'agent_citation'
+ASSISTANT_ARTIFACT_CHUNK_SIZE = 180000
+COMPACT_VALUE_MAX_STRING = 400
+COMPACT_VALUE_MAX_LIST_ITEMS = 5
+COMPACT_VALUE_MAX_DICT_KEYS = 12
+COMPACT_VALUE_MAX_DEPTH = 3
+TABULAR_ARGUMENT_EXCLUDE_KEYS = {
+    'conversation_id',
+    'group_id',
+    'public_workspace_id',
+    'source',
+    'user_id',
+}
+
+
+def is_assistant_artifact_role(role: Optional[str]) -> bool:
+    """Return True for auxiliary assistant artifact records stored in messages."""
+    return role in {ASSISTANT_ARTIFACT_ROLE, ASSISTANT_ARTIFACT_CHUNK_ROLE}
+
+
+def filter_assistant_artifact_items(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Return only primary conversation items, excluding assistant artifacts and chunks."""
+    return [item for item in items or [] if not is_assistant_artifact_role(item.get('role'))]
+
+
+def make_json_serializable(value: Any) -> Any:
+    """Convert nested values into JSON-serializable structures."""
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, dict):
+        return {str(key): make_json_serializable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [make_json_serializable(item) for item in value]
+    return str(value)
+
+
+def build_agent_citation_artifact_documents(
+    conversation_id: str,
+    assistant_message_id: str,
+    agent_citations: List[Dict[str, Any]],
+    created_timestamp: str,
+    user_info: Optional[Dict[str, Any]] = None,
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Return compact citations plus auxiliary message records for full raw payloads."""
+    compact_citations: List[Dict[str, Any]] = []
+    artifact_docs: List[Dict[str, Any]] = []
+
+    for index, citation in enumerate(agent_citations or [], start=1):
+        serializable_citation = make_json_serializable(citation)
+        artifact_id = f"{assistant_message_id}_artifact_{index}"
+
+        compact_citations.append(
+            build_compact_agent_citation(serializable_citation, artifact_id=artifact_id)
+        )
+        artifact_docs.extend(
+            _build_artifact_documents(
+                conversation_id=conversation_id,
+                assistant_message_id=assistant_message_id,
+                artifact_id=artifact_id,
+                artifact_kind=ASSISTANT_ARTIFACT_KIND_AGENT_CITATION,
+                payload={
+                    'schema_version': 1,
+                    'artifact_kind': ASSISTANT_ARTIFACT_KIND_AGENT_CITATION,
+                    'citation': serializable_citation,
+                },
+                created_timestamp=created_timestamp,
+                artifact_index=index,
+                user_info=user_info,
+                citation=serializable_citation if isinstance(serializable_citation, dict) else None,
+            )
+        )
+
+    return compact_citations, artifact_docs
+
+
+def build_message_artifact_payload_map(raw_messages: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    """Reassemble assistant artifact records into a payload map keyed by artifact id."""
+    artifact_messages: Dict[str, Dict[str, Any]] = {}
+    artifact_chunks: Dict[str, Dict[int, str]] = {}
+
+    for message in raw_messages or []:
+        role = message.get('role')
+        if role == ASSISTANT_ARTIFACT_ROLE:
+            artifact_messages[message.get('id')] = message
+        elif role == ASSISTANT_ARTIFACT_CHUNK_ROLE:
+            parent_id = message.get('parent_message_id')
+            if not parent_id:
+                continue
+            artifact_chunks.setdefault(parent_id, {})[
+                int((message.get('metadata') or {}).get('chunk_index', 0))
+            ] = str(message.get('content', ''))
+
+    artifact_payloads: Dict[str, Dict[str, Any]] = {}
+    for artifact_id, artifact_message in artifact_messages.items():
+        content = str(artifact_message.get('content', ''))
+        metadata = artifact_message.get('metadata', {}) or {}
+
+        if metadata.get('is_chunked'):
+            total_chunks = int(metadata.get('total_chunks', 1) or 1)
+            chunk_map = artifact_chunks.get(artifact_id, {})
+            rebuilt_chunks = [content]
+            for chunk_index in range(1, total_chunks):
+                rebuilt_chunks.append(chunk_map.get(chunk_index, ''))
+            content = ''.join(rebuilt_chunks)
+
+        try:
+            parsed = json.loads(content)
+        except Exception:
+            continue
+
+        if isinstance(parsed, dict):
+            artifact_payloads[artifact_id] = parsed
+
+    return artifact_payloads
+
+
+def hydrate_agent_citations_from_artifacts(
+    messages: List[Dict[str, Any]],
+    artifact_payload_map: Dict[str, Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    """Return messages with agent citations inflated from assistant artifact records."""
+    hydrated_messages: List[Dict[str, Any]] = []
+
+    for message in messages or []:
+        hydrated_message = deepcopy(message)
+        agent_citations = hydrated_message.get('agent_citations')
+        if not isinstance(agent_citations, list) or not agent_citations:
+            hydrated_messages.append(hydrated_message)
+            continue
+
+        hydrated_citations = []
+        for citation in agent_citations:
+            if not isinstance(citation, dict):
+                hydrated_citations.append(citation)
+                continue
+
+            artifact_id = citation.get('artifact_id')
+            artifact_payload = artifact_payload_map.get(str(artifact_id or ''))
+            raw_citation = artifact_payload.get('citation') if isinstance(artifact_payload, dict) else None
+            if isinstance(raw_citation, dict):
+                merged_citation = deepcopy(raw_citation)
+                merged_citation.setdefault('artifact_id', artifact_id)
+                merged_citation.setdefault('raw_payload_externalized', True)
+                hydrated_citations.append(merged_citation)
+            else:
+                hydrated_citations.append(citation)
+
+        hydrated_message['agent_citations'] = hydrated_citations
+        hydrated_messages.append(hydrated_message)
+
+    return hydrated_messages
+
+
+def build_compact_agent_citation(citation: Any, artifact_id: Optional[str] = None) -> Dict[str, Any]:
+    """Build a compact citation record suitable for storing on the assistant message."""
+    if not isinstance(citation, dict):
+        compact_value = _compact_value(citation)
+        compact_citation = {
+            'tool_name': 'Tool invocation',
+            'function_result': compact_value,
+        }
+        if artifact_id:
+            compact_citation['artifact_id'] = artifact_id
+            compact_citation['raw_payload_externalized'] = True
+        return compact_citation
+
+    function_name = str(citation.get('function_name') or '').strip()
+    plugin_name = str(citation.get('plugin_name') or '').strip()
+    compact_citation = {
+        'tool_name': citation.get('tool_name') or function_name or 'Tool invocation',
+        'function_name': citation.get('function_name'),
+        'plugin_name': citation.get('plugin_name'),
+        'duration_ms': citation.get('duration_ms'),
+        'timestamp': citation.get('timestamp'),
+        'success': citation.get('success'),
+        'error_message': _compact_value(citation.get('error_message')),
+        'function_arguments': _compact_function_arguments(
+            citation.get('function_arguments'),
+            function_name=function_name,
+            plugin_name=plugin_name,
+        ),
+        'function_result': _compact_function_result(
+            citation.get('function_result'),
+            function_name=function_name,
+            plugin_name=plugin_name,
+        ),
+    }
+    if artifact_id:
+        compact_citation['artifact_id'] = artifact_id
+        compact_citation['raw_payload_externalized'] = True
+    return _remove_empty_values(compact_citation)
+
+
+def _build_artifact_documents(
+    conversation_id: str,
+    assistant_message_id: str,
+    artifact_id: str,
+    artifact_kind: str,
+    payload: Dict[str, Any],
+    created_timestamp: str,
+    artifact_index: int,
+    user_info: Optional[Dict[str, Any]] = None,
+    citation: Optional[Dict[str, Any]] = None,
+) -> List[Dict[str, Any]]:
+    serialized_payload = json.dumps(payload, default=str)
+    chunks = [
+        serialized_payload[index:index + ASSISTANT_ARTIFACT_CHUNK_SIZE]
+        for index in range(0, len(serialized_payload), ASSISTANT_ARTIFACT_CHUNK_SIZE)
+    ] or ['']
+
+    base_metadata = {
+        'artifact_type': artifact_kind,
+        'artifact_index': artifact_index,
+        'is_chunked': len(chunks) > 1,
+        'total_chunks': len(chunks),
+        'chunk_index': 0,
+        'root_message_id': assistant_message_id,
+        'user_info': user_info,
+    }
+    if citation:
+        base_metadata.update({
+            'tool_name': citation.get('tool_name'),
+            'function_name': citation.get('function_name'),
+            'plugin_name': citation.get('plugin_name'),
+        })
+
+    main_doc = {
+        'id': artifact_id,
+        'conversation_id': conversation_id,
+        'role': ASSISTANT_ARTIFACT_ROLE,
+        'content': chunks[0],
+        'parent_message_id': assistant_message_id,
+        'artifact_kind': artifact_kind,
+        'timestamp': created_timestamp,
+        'metadata': base_metadata,
+    }
+
+    docs = [main_doc]
+    for chunk_index in range(1, len(chunks)):
+        docs.append({
+            'id': f"{artifact_id}_chunk_{chunk_index}",
+            'conversation_id': conversation_id,
+            'role': ASSISTANT_ARTIFACT_CHUNK_ROLE,
+            'content': chunks[chunk_index],
+            'parent_message_id': artifact_id,
+            'artifact_kind': artifact_kind,
+            'timestamp': created_timestamp,
+            'metadata': {
+                'artifact_type': artifact_kind,
+                'artifact_index': artifact_index,
+                'is_chunk': True,
+                'chunk_index': chunk_index,
+                'total_chunks': len(chunks),
+                'parent_message_id': artifact_id,
+                'root_message_id': assistant_message_id,
+                'user_info': user_info,
+            },
+        })
+
+    return docs
+
+
+def _compact_function_arguments(arguments: Any, function_name: str, plugin_name: str) -> Any:
+    parsed_arguments = _parse_json_if_possible(arguments)
+    if not isinstance(parsed_arguments, dict):
+        return _compact_value(parsed_arguments)
+
+    if _is_tabular_citation(function_name, plugin_name):
+        filtered_arguments = {
+            key: value
+            for key, value in parsed_arguments.items()
+            if key not in TABULAR_ARGUMENT_EXCLUDE_KEYS
+        }
+        return _compact_value(filtered_arguments)
+
+    return _compact_value(parsed_arguments)
+
+
+def _compact_function_result(result: Any, function_name: str, plugin_name: str) -> Any:
+    parsed_result = _parse_json_if_possible(result)
+    if _is_tabular_citation(function_name, plugin_name):
+        return _compact_tabular_result_payload(function_name, parsed_result)
+    return _compact_value(parsed_result)
+
+
+def _compact_tabular_result_payload(function_name: str, payload: Any) -> Any:
+    if not isinstance(payload, dict):
+        return _compact_value(payload)
+
+    summary: Dict[str, Any] = {}
+    preferred_keys = [
+        'filename',
+        'selected_sheet',
+        'lookup_column',
+        'lookup_value',
+        'target_column',
+        'match_operator',
+        'column',
+        'operation',
+        'group_by',
+        'aggregate_column',
+        'date_component',
+        'query_expression',
+        'total_matches',
+        'returned_rows',
+        'groups',
+        'value',
+        'result',
+        'highest_group',
+        'highest_value',
+        'lowest_group',
+        'lowest_value',
+        'error',
+        'candidate_sheets',
+        'sheet_count',
+    ]
+
+    for key in preferred_keys:
+        if key in payload:
+            summary[key] = _compact_value(payload.get(key), depth=1)
+
+    if isinstance(payload.get('top_results'), dict):
+        summary['top_results'] = _compact_value(payload.get('top_results'), depth=1)
+
+    if isinstance(payload.get('details'), list):
+        summary['details'] = _compact_value(payload.get('details'), depth=1)
+
+    data_rows = payload.get('data')
+    if isinstance(data_rows, list) and data_rows:
+        summary['sample_rows'] = [_compact_value(row, depth=1) for row in data_rows[:3]]
+        summary['sample_rows_limited'] = len(data_rows) > 3 or int(payload.get('returned_rows') or 0) > 3
+
+    if function_name == 'lookup_value' and 'value' not in summary and isinstance(data_rows, list) and len(data_rows) == 1:
+        summary['sample_rows'] = [_compact_value(data_rows[0], depth=1)]
+
+    return _remove_empty_values(summary)
+
+
+def _compact_value(value: Any, depth: int = 0) -> Any:
+    if value is None or isinstance(value, (int, float, bool)):
+        return value
+
+    if isinstance(value, str):
+        if len(value) <= COMPACT_VALUE_MAX_STRING:
+            return value
+        return f"{value[:COMPACT_VALUE_MAX_STRING]}... [truncated {len(value) - COMPACT_VALUE_MAX_STRING} chars]"
+
+    if depth >= COMPACT_VALUE_MAX_DEPTH:
+        if isinstance(value, dict):
+            return f"<dict with {len(value)} keys>"
+        if isinstance(value, list):
+            return f"<list with {len(value)} items>"
+        return str(value)
+
+    if isinstance(value, list):
+        compact_items = [_compact_value(item, depth=depth + 1) for item in value[:COMPACT_VALUE_MAX_LIST_ITEMS]]
+        if len(value) > COMPACT_VALUE_MAX_LIST_ITEMS:
+            compact_items.append({'remaining_items': len(value) - COMPACT_VALUE_MAX_LIST_ITEMS})
+        return compact_items
+
+    if isinstance(value, dict):
+        compact_mapping: Dict[str, Any] = {}
+        for index, (key, item) in enumerate(value.items()):
+            if index >= COMPACT_VALUE_MAX_DICT_KEYS:
+                compact_mapping['remaining_keys'] = len(value) - COMPACT_VALUE_MAX_DICT_KEYS
+                break
+            compact_mapping[str(key)] = _compact_value(item, depth=depth + 1)
+        return compact_mapping
+
+    return str(value)
+
+
+def _parse_json_if_possible(value: Any) -> Any:
+    if not isinstance(value, str):
+        return value
+
+    trimmed = value.strip()
+    if not trimmed or trimmed[0] not in '{[':
+        return value
+
+    try:
+        return json.loads(trimmed)
+    except Exception:
+        return value
+
+
+def _is_tabular_citation(function_name: str, plugin_name: str) -> bool:
+    return plugin_name == 'TabularProcessingPlugin' or function_name in {
+        'aggregate_column',
+        'describe_tabular_file',
+        'filter_rows',
+        'group_by_aggregate',
+        'group_by_datetime_component',
+        'lookup_value',
+        'query_tabular_data',
+    }
+
+
+def _remove_empty_values(mapping: Dict[str, Any]) -> Dict[str, Any]:
+    cleaned: Dict[str, Any] = {}
+    for key, value in mapping.items():
+        if value in (None, '', [], {}):
+            continue
+        cleaned[key] = value
+    return cleaned
\ No newline at end of file
diff --git a/application/single_app/json_schema_validation.py b/application/single_app/json_schema_validation.py
index 8bc3ae88..abfbcb90 100644
--- a/application/single_app/json_schema_validation.py
+++ b/application/single_app/json_schema_validation.py
@@ -7,6 +7,26 @@
 
 SCHEMA_DIR = os.path.join(os.path.dirname(__file__), 'static', 'json', 'schemas')
 
+PLUGIN_STORAGE_MANAGED_FIELDS = {
+    '_attachments',
+    '_etag',
+    '_rid',
+    '_self',
+    '_ts',
+    'created_at',
+    'created_by',
+    'group_id',
+    'id',
+    'is_global',
+    'is_group',
+    'last_updated',
+    'modified_at',
+    'modified_by',
+    'scope',
+    'updated_at',
+    'user_id',
+}
+
 @lru_cache(maxsize=8)
 def load_schema(schema_name):
     path = os.path.join(SCHEMA_DIR, schema_name)
@@ -33,11 +53,9 @@ def validate_plugin(plugin):
     plugin_copy = plugin.copy()
     plugin_type = plugin_copy.get('type', '')
     
-    # Remove Cosmos DB system fields that are not part of the plugin schema
-    cosmos_fields = ['_attachments', '_etag', '_rid', '_self', '_ts', 'created_at', 'updated_at', 'id', 'user_id', 'last_updated']
-    for field in cosmos_fields:
-        if field in plugin_copy:
-            del plugin_copy[field]
+    # Remove storage-managed fields that appear on persisted plugin documents but are not part of the schema.
+    for field in PLUGIN_STORAGE_MANAGED_FIELDS:
+        plugin_copy.pop(field, None)
     
     if plugin_type in ['sql_schema', 'sql_query'] and not plugin_copy.get('endpoint'):
         plugin_copy['endpoint'] = f'sql://{plugin_type}'
diff --git a/application/single_app/route_backend_chats.py b/application/single_app/route_backend_chats.py
index 2f40fb54..a0b46a49 100644
--- a/application/single_app/route_backend_chats.py
+++ b/application/single_app/route_backend_chats.py
@@ -43,9 +43,67 @@
 from swagger_wrapper import swagger_route, get_auth_security
 from azure.identity import ClientSecretCredential, DefaultAzureCredential, get_bearer_token_provider
 from functions_keyvault import SecretReturnType, keyvault_model_endpoint_get_helper
+from functions_message_artifacts import (
+    build_agent_citation_artifact_documents,
+    filter_assistant_artifact_items,
+)
 from functions_thoughts import ThoughtTracker
 
 
+def _strip_agent_citation_artifact_refs(agent_citations):
+    """Drop artifact references when auxiliary payload persistence fails."""
+    compact_citations = []
+    for citation in agent_citations or []:
+        if not isinstance(citation, dict):
+            compact_citations.append(citation)
+            continue
+
+        compact_citation = dict(citation)
+        compact_citation.pop('artifact_id', None)
+        compact_citation.pop('raw_payload_externalized', None)
+        compact_citations.append(compact_citation)
+
+    return compact_citations
+
+
+def persist_agent_citation_artifacts(
+    conversation_id,
+    assistant_message_id,
+    agent_citations,
+    created_timestamp,
+    user_info=None,
+):
+    """Persist raw agent citation payloads outside the primary assistant message doc."""
+    if not agent_citations:
+        return []
+
+    compact_citations, artifact_docs = build_agent_citation_artifact_documents(
+        conversation_id=conversation_id,
+        assistant_message_id=assistant_message_id,
+        agent_citations=agent_citations,
+        created_timestamp=created_timestamp,
+        user_info=user_info,
+    )
+
+    try:
+        for artifact_doc in artifact_docs:
+            cosmos_messages_container.upsert_item(artifact_doc)
+        return compact_citations
+    except Exception as exc:
+        log_event(
+            f"[Agent Citations] Failed to persist assistant artifacts: {exc}",
+            extra={
+                'conversation_id': conversation_id,
+                'assistant_message_id': assistant_message_id,
+                'artifact_count': len(artifact_docs),
+                'citation_count': len(agent_citations),
+            },
+            level=logging.WARNING,
+            exceptionTraceback=True,
+        )
+        return _strip_agent_citation_artifact_refs(compact_citations)
+
+
 def get_tabular_discovery_function_names():
     """Return discovery-oriented tabular function names from the plugin."""
     from semantic_kernel_plugins.tabular_processing_plugin import TabularProcessingPlugin
@@ -230,10 +288,18 @@ def build_search_augmentation_system_prompt(retrieved_content):
 
 def build_tabular_computed_results_system_message(source_label, tabular_analysis):
     """Build the outer-model handoff message for successful tabular analysis."""
+    rendered_analysis = str(tabular_analysis or '').strip()
+    max_handoff_chars = 24000
+    if len(rendered_analysis) > max_handoff_chars:
+        rendered_analysis = (
+            rendered_analysis[:max_handoff_chars]
+            + "\n[Computed results handoff truncated for prompt budget.]"
+        )
+
     return (
         f"The following tabular results were computed from {source_label} using "
         f"tabular_processing plugin functions:\n\n"
-        f"{tabular_analysis}\n\n"
+        f"{rendered_analysis}\n\n"
         "These are tool-backed results derived from the full underlying tabular data, not just retrieved schema excerpts. "
         "Treat them as authoritative for row-level facts, calculations, and numeric conclusions. "
         "Do not say that you lack direct access to the data if the answer is present in these computed results."
@@ -722,7 +788,50 @@ def describe_tabular_invocation_conditions(invocation):
     return None
 
 
-def get_tabular_query_overlap_summary(invocations, max_rows=25):
+def compact_tabular_fallback_value(value, depth=0, max_depth=2):
+    """Reduce large tabular fallback values to prompt-safe summaries."""
+    if value is None or isinstance(value, (int, float, bool)):
+        return value
+
+    if isinstance(value, str):
+        max_string_length = 400
+        if len(value) <= max_string_length:
+            return value
+        return f"{value[:max_string_length]}... [truncated {len(value) - max_string_length} chars]"
+
+    if depth >= max_depth:
+        if isinstance(value, dict):
+            return f"<dict with {len(value)} keys>"
+        if isinstance(value, list):
+            return f"<list with {len(value)} items>"
+        return str(value)
+
+    if isinstance(value, list):
+        compact_items = [
+            compact_tabular_fallback_value(item, depth=depth + 1, max_depth=max_depth)
+            for item in value[:5]
+        ]
+        if len(value) > 5:
+            compact_items.append({'remaining_items': len(value) - 5})
+        return compact_items
+
+    if isinstance(value, dict):
+        compact_mapping = {}
+        for index, (key, item) in enumerate(value.items()):
+            if index >= 12:
+                compact_mapping['remaining_keys'] = len(value) - 12
+                break
+            compact_mapping[str(key)] = compact_tabular_fallback_value(
+                item,
+                depth=depth + 1,
+                max_depth=max_depth,
+            )
+        return compact_mapping
+
+    return str(value)
+
+
+def get_tabular_query_overlap_summary(invocations, max_rows=10):
     """Summarize overlap across successful row-returning tabular calls.
 
     This is a defensive fallback for cases where tool execution succeeded but the
@@ -786,7 +895,7 @@ def get_tabular_query_overlap_summary(invocations, max_rows=25):
             if row_key not in overlapping_keys or row_key in seen_sample_keys:
                 continue
 
-            ordered_sample_rows.append(row)
+            ordered_sample_rows.append(compact_tabular_fallback_value(row))
             seen_sample_keys.add(row_key)
             if len(ordered_sample_rows) >= max_rows:
                 break
@@ -795,7 +904,7 @@ def get_tabular_query_overlap_summary(invocations, max_rows=25):
         for grouped_item in grouped_items:
             rendered_conditions = describe_tabular_invocation_conditions(grouped_item['invocation'])
             if rendered_conditions:
-                source_queries.append(rendered_conditions)
+                source_queries.append(compact_tabular_fallback_value(rendered_conditions))
 
         overlap_summary = {
             'filename': filename or None,
@@ -813,7 +922,7 @@ def get_tabular_query_overlap_summary(invocations, max_rows=25):
     return best_summary
 
 
-def get_tabular_invocation_compact_payload(invocation, max_rows=10):
+def get_tabular_invocation_compact_payload(invocation, max_rows=5):
     """Return a compact, prompt-safe summary of a successful tabular invocation."""
     result_payload = get_tabular_invocation_result_payload(invocation)
     if not result_payload:
@@ -822,15 +931,15 @@ def get_tabular_invocation_compact_payload(invocation, max_rows=10):
     function_name = getattr(invocation, 'function_name', '')
     compact_payload = {
         'function': function_name,
-        'filename': result_payload.get('filename'),
-        'selected_sheet': result_payload.get('selected_sheet'),
+        'filename': compact_tabular_fallback_value(result_payload.get('filename')),
+        'selected_sheet': compact_tabular_fallback_value(result_payload.get('selected_sheet')),
     }
 
     if function_name == 'aggregate_column':
         compact_payload.update({
-            'column': result_payload.get('column'),
-            'operation': result_payload.get('operation'),
-            'result': result_payload.get('result'),
+            'column': compact_tabular_fallback_value(result_payload.get('column')),
+            'operation': compact_tabular_fallback_value(result_payload.get('operation')),
+            'result': compact_tabular_fallback_value(result_payload.get('result')),
         })
     elif function_name in {'group_by_aggregate', 'group_by_datetime_component'}:
         for key_name in (
@@ -846,7 +955,7 @@ def get_tabular_invocation_compact_payload(invocation, max_rows=10):
             'top_results',
         ):
             if key_name in result_payload:
-                compact_payload[key_name] = result_payload.get(key_name)
+                compact_payload[key_name] = compact_tabular_fallback_value(result_payload.get(key_name))
     elif function_name == 'lookup_value':
         for key_name in (
             'lookup_column',
@@ -857,27 +966,39 @@ def get_tabular_invocation_compact_payload(invocation, max_rows=10):
             'returned_rows',
         ):
             if key_name in result_payload:
-                compact_payload[key_name] = result_payload.get(key_name)
+                compact_payload[key_name] = compact_tabular_fallback_value(result_payload.get(key_name))
 
         data_rows = get_tabular_invocation_data_rows(invocation)
         if data_rows:
-            compact_payload['sample_rows'] = data_rows[:max_rows]
+            compact_payload['sample_rows'] = [
+                compact_tabular_fallback_value(row)
+                for row in data_rows[:max_rows]
+            ]
             compact_payload['sample_rows_limited'] = len(data_rows) > max_rows
     elif function_name in {'query_tabular_data', 'filter_rows'}:
         for key_name in ('total_matches', 'returned_rows'):
             if key_name in result_payload:
-                compact_payload[key_name] = result_payload.get(key_name)
+                compact_payload[key_name] = compact_tabular_fallback_value(result_payload.get(key_name))
 
         data_rows = get_tabular_invocation_data_rows(invocation)
         if data_rows:
-            compact_payload['sample_rows'] = data_rows[:max_rows]
+            compact_payload['sample_rows'] = [
+                compact_tabular_fallback_value(row)
+                for row in data_rows[:max_rows]
+            ]
             compact_payload['sample_rows_limited'] = len(data_rows) > max_rows
 
         rendered_conditions = describe_tabular_invocation_conditions(invocation)
         if rendered_conditions:
-            compact_payload['conditions'] = rendered_conditions
+            compact_payload['conditions'] = compact_tabular_fallback_value(rendered_conditions)
     else:
-        compact_payload.update(result_payload)
+        compact_payload.update({
+            key: compact_tabular_fallback_value(value)
+            for key, value in result_payload.items()
+        })
+
+    if '[truncated ' in json.dumps(compact_payload, default=str):
+        compact_payload['result_summary_truncated'] = True
 
     return compact_payload
 
@@ -895,34 +1016,88 @@ def build_tabular_analysis_fallback_from_invocations(invocations):
     if not successful_invocations:
         return None
 
-    overlap_summary = get_tabular_query_overlap_summary(successful_invocations)
-    compact_results = []
-    for invocation in successful_invocations[:8]:
-        compact_payload = get_tabular_invocation_compact_payload(invocation)
-        if compact_payload is None:
-            continue
-        compact_results.append(compact_payload)
-
-    if not overlap_summary and not compact_results:
-        return None
-
+    max_fallback_chars = 24000
+    coverage_note_reserve = 1200
+    overlap_summary = get_tabular_query_overlap_summary(successful_invocations, max_rows=10)
     rendered_sections = [
         "The following structured results come directly from successful tabular tool executions.",
         "Use them as computed evidence even though the inner tabular synthesis step did not complete.",
     ]
 
     if overlap_summary:
+        if overlap_summary.get('sample_rows') and len(json.dumps(overlap_summary, default=str)) > 6000:
+            overlap_summary = dict(overlap_summary)
+            overlap_summary['sample_rows'] = overlap_summary.get('sample_rows', [])[:5]
+            overlap_summary['sample_rows_limited'] = True
+
         rendered_sections.append(
             "OVERLAP SUMMARY:\n"
             f"{json.dumps(overlap_summary, indent=2, default=str)}"
         )
 
+    base_rendered_text = "\n\n".join(rendered_sections)
+    compact_results = []
+    invocation_limit = 8
+    candidate_invocations = successful_invocations[:invocation_limit]
+    for invocation in candidate_invocations:
+        compact_payload = get_tabular_invocation_compact_payload(invocation, max_rows=5)
+        if compact_payload is None:
+            continue
+
+        candidate_results = compact_results + [compact_payload]
+        candidate_section = (
+            "TOOL RESULT SUMMARIES:\n"
+            f"{json.dumps(candidate_results, indent=2, default=str)}"
+        )
+        candidate_text = base_rendered_text + ("\n\n" if base_rendered_text else "") + candidate_section
+        if len(candidate_text) <= (max_fallback_chars - coverage_note_reserve):
+            compact_results = candidate_results
+            continue
+
+        if compact_results:
+            break
+
+        shrunk_payload = dict(compact_payload)
+        if 'sample_rows' in shrunk_payload:
+            shrunk_payload['sample_rows'] = shrunk_payload['sample_rows'][:2]
+            shrunk_payload['sample_rows_limited'] = True
+        if isinstance(shrunk_payload.get('top_results'), dict):
+            shrunk_payload['top_results'] = dict(list(shrunk_payload['top_results'].items())[:3])
+
+        candidate_section = (
+            "TOOL RESULT SUMMARIES:\n"
+            f"{json.dumps([shrunk_payload], indent=2, default=str)}"
+        )
+        candidate_text = base_rendered_text + ("\n\n" if base_rendered_text else "") + candidate_section
+        if len(candidate_text) > (max_fallback_chars - coverage_note_reserve):
+            shrunk_payload.pop('sample_rows', None)
+            shrunk_payload['sample_rows_limited'] = True
+            shrunk_payload['result_summary_truncated'] = True
+            if isinstance(shrunk_payload.get('top_results'), dict):
+                shrunk_payload['top_results'] = dict(list(shrunk_payload['top_results'].items())[:2])
+
+        compact_results = [shrunk_payload]
+        break
+
+    if not overlap_summary and not compact_results:
+        return None
+
     if compact_results:
         rendered_sections.append(
             "TOOL RESULT SUMMARIES:\n"
             f"{json.dumps(compact_results, indent=2, default=str)}"
         )
 
+    omitted_invocation_count = len(candidate_invocations) - len(compact_results)
+    if len(successful_invocations) > invocation_limit:
+        omitted_invocation_count += len(successful_invocations) - invocation_limit
+    if omitted_invocation_count > 0:
+        rendered_sections.append(
+            "RESULT COVERAGE NOTE:\n"
+            f"Included {len(compact_results)} compact tool summaries out of {len(successful_invocations)} successful tool executions to stay within the prompt budget. "
+            "Use targeted follow-up tool calls if additional raw detail is required."
+        )
+
     return "\n\n".join(rendered_sections)
 
 
@@ -4422,6 +4597,7 @@ def result_requires_message_reload(result: Any) -> bool:
                 all_messages = list(cosmos_messages_container.query_items(
                     query=all_messages_query, parameters=params_all, partition_key=conversation_id, enable_cross_partition_query=True
                 ))
+                all_messages = filter_assistant_artifact_items(all_messages)
 
                 # Sort messages using threading logic
                 all_messages = sort_messages_by_thread(all_messages)
@@ -5589,18 +5765,26 @@ def gpt_error(e):
             
             # Assistant message should be part of the same thread as the user message
             # Only system/augmentation messages create new threads within a conversation
+            assistant_timestamp = datetime.utcnow().isoformat()
+            prepared_agent_citations = persist_agent_citation_artifacts(
+                conversation_id=conversation_id,
+                assistant_message_id=assistant_message_id,
+                agent_citations=agent_citations_list,
+                created_timestamp=assistant_timestamp,
+                user_info=user_info_for_assistant,
+            )
+
             assistant_doc = {
                 'id': assistant_message_id,
                 'conversation_id': conversation_id,
                 'role': 'assistant',
                 'content': ai_message,
-                'timestamp': datetime.utcnow().isoformat(),
+                'timestamp': assistant_timestamp,
                 'augmented': bool(system_messages_for_augmentation),
                 'hybrid_citations': hybrid_citations_list, # <--- SIMPLIFIED: Directly use the list
                 'web_search_citations': web_search_citations_list,
                 'hybridsearch_query': search_query if hybrid_search_enabled and search_results else None, # Log query only if hybrid search ran and found results
-                'agent_citations': agent_citations_list, # <--- NEW: Store agent tool invocation results
-                'user_message': user_message,
+                'agent_citations': prepared_agent_citations,
                 'model_deployment_name': actual_model_used,
                 'agent_display_name': agent_display_name,
                 'agent_name': agent_name,
@@ -5737,7 +5921,7 @@ def gpt_error(e):
                 'augmented': bool(system_messages_for_augmentation),
                 'hybrid_citations': hybrid_citations_list,
                 'web_search_citations': web_search_citations_list,
-                'agent_citations': agent_citations_list,
+                'agent_citations': prepared_agent_citations,
                 'reload_messages': reload_messages_required,
                 'kernel_fallback_notice': kernel_fallback_notice,
                 'thoughts_enabled': thought_tracker.enabled
@@ -6876,6 +7060,7 @@ def publish_live_plugin_thought(thought_payload):
                         query=all_messages_query, parameters=params_all, 
                         partition_key=conversation_id, enable_cross_partition_query=True
                     ))
+                    all_messages = filter_assistant_artifact_items(all_messages)
                     
                     # Sort messages using threading logic
                     all_messages = sort_messages_by_thread(all_messages)
@@ -7481,28 +7666,37 @@ def make_json_serializable(obj):
                     # Get user thread info to maintain thread consistency
                     user_thread_id = None
                     user_previous_thread_id = None
+                    user_info_for_assistant = None
                     try:
                         user_msg = cosmos_messages_container.read_item(
                             item=user_message_id,
                             partition_key=conversation_id
                         )
+                        user_info_for_assistant = user_msg.get('metadata', {}).get('user_info')
                         user_thread_id = user_msg.get('metadata', {}).get('thread_info', {}).get('thread_id')
                         user_previous_thread_id = user_msg.get('metadata', {}).get('thread_info', {}).get('previous_thread_id')
                     except Exception as e:
                         debug_print(f"Warning: Could not retrieve thread_id from user message: {e}")
-                    
+                    assistant_timestamp = datetime.utcnow().isoformat()
+                    prepared_agent_citations = persist_agent_citation_artifacts(
+                        conversation_id=conversation_id,
+                        assistant_message_id=assistant_message_id,
+                        agent_citations=agent_citations_list,
+                        created_timestamp=assistant_timestamp,
+                        user_info=user_info_for_assistant,
+                    )
+
                     assistant_doc = {
                         'id': assistant_message_id,
                         'conversation_id': conversation_id,
                         'role': 'assistant',
                         'content': accumulated_content,
-                        'timestamp': datetime.utcnow().isoformat(),
+                        'timestamp': assistant_timestamp,
                         'augmented': bool(system_messages_for_augmentation),
                         'hybrid_citations': hybrid_citations_list,
                         'web_search_citations': web_search_citations_list,
                         'hybridsearch_query': search_query if hybrid_search_enabled and search_results else None,
-                        'agent_citations': agent_citations_list,
-                        'user_message': user_message,
+                        'agent_citations': prepared_agent_citations,
                         'model_deployment_name': final_model_used if use_agent_streaming else gpt_model,
                         'agent_display_name': agent_display_name_used if use_agent_streaming else None,
                         'agent_name': agent_name_used if use_agent_streaming else None,
@@ -7621,7 +7815,7 @@ def make_json_serializable(obj):
                         'augmented': bool(system_messages_for_augmentation),
                         'hybrid_citations': hybrid_citations_list,
                         'web_search_citations': web_search_citations_list,
-                        'agent_citations': agent_citations_list,
+                        'agent_citations': prepared_agent_citations,
                         'agent_display_name': agent_display_name_used if use_agent_streaming else None,
                         'agent_name': agent_name_used if use_agent_streaming else None,
                         'full_content': accumulated_content,
@@ -7643,19 +7837,26 @@ def make_json_serializable(obj):
                     # Save partial response if we have content
                     if accumulated_content:
                         current_assistant_thread_id = str(uuid.uuid4())
+                        assistant_timestamp = datetime.utcnow().isoformat()
+                        prepared_agent_citations = persist_agent_citation_artifacts(
+                            conversation_id=conversation_id,
+                            assistant_message_id=assistant_message_id,
+                            agent_citations=agent_citations_list,
+                            created_timestamp=assistant_timestamp,
+                            user_info=user_info_for_assistant,
+                        )
                         
                         assistant_doc = {
                             'id': assistant_message_id,
                             'conversation_id': conversation_id,
                             'role': 'assistant',
                             'content': accumulated_content,
-                            'timestamp': datetime.utcnow().isoformat(),
+                            'timestamp': assistant_timestamp,
                             'augmented': bool(system_messages_for_augmentation),
                             'hybrid_citations': hybrid_citations_list,
                             'web_search_citations': web_search_citations_list,
                             'hybridsearch_query': search_query if hybrid_search_enabled and search_results else None,
-                            'agent_citations': agent_citations_list,
-                            'user_message': user_message,
+                            'agent_citations': prepared_agent_citations,
                             'model_deployment_name': final_model_used if use_agent_streaming else gpt_model,
                             'agent_display_name': agent_display_name_used if use_agent_streaming else None,
                             'agent_name': agent_name_used if use_agent_streaming else None,
diff --git a/application/single_app/route_backend_conversation_export.py b/application/single_app/route_backend_conversation_export.py
index 689d3476..b070c222 100644
--- a/application/single_app/route_backend_conversation_export.py
+++ b/application/single_app/route_backend_conversation_export.py
@@ -18,6 +18,11 @@
 from functions_chat import sort_messages_by_thread
 from functions_conversation_metadata import update_conversation_with_metadata
 from functions_debug import debug_print
+from functions_message_artifacts import (
+    build_message_artifact_payload_map,
+    hydrate_agent_citations_from_artifacts,
+    is_assistant_artifact_role,
+)
 from functions_settings import *
 from functions_thoughts import get_thoughts_for_conversation
 from swagger_wrapper import swagger_route, get_auth_security
@@ -188,6 +193,20 @@ def api_export_message_word():
             if message.get('conversation_id') != conversation_id:
                 return jsonify({'error': 'Message not found'}), 404
 
+            if isinstance(message.get('agent_citations'), list) and any(
+                isinstance(citation, dict) and citation.get('artifact_id')
+                for citation in message.get('agent_citations', [])
+            ):
+                conversation_messages = list(cosmos_messages_container.query_items(
+                    query="SELECT * FROM c WHERE c.conversation_id = @conversation_id",
+                    parameters=[{'name': '@conversation_id', 'value': conversation_id}],
+                    partition_key=conversation_id,
+                ))
+                artifact_payload_map = build_message_artifact_payload_map(conversation_messages)
+                hydrated_messages = hydrate_agent_citations_from_artifacts([message], artifact_payload_map)
+                if hydrated_messages:
+                    message = hydrated_messages[0]
+
             document_bytes = _message_to_docx_bytes(message)
             timestamp_str = datetime.utcnow().strftime('%Y%m%d_%H%M%S')
             filename = f"message_export_{timestamp_str}.docx"
@@ -213,7 +232,9 @@ def _build_export_entry(
     include_summary_intro: bool = False,
     summary_model_deployment: str = ''
 ) -> Dict[str, Any]:
+    artifact_payload_map = build_message_artifact_payload_map(raw_messages)
     filtered_messages = _filter_messages_for_export(raw_messages)
+    filtered_messages = hydrate_agent_citations_from_artifacts(filtered_messages, artifact_payload_map)
     ordered_messages = sort_messages_by_thread(filtered_messages)
 
     raw_thoughts = get_thoughts_for_conversation(conversation.get('id'), user_id)
@@ -285,6 +306,9 @@ def _build_export_entry(
 def _filter_messages_for_export(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     filtered_messages = []
     for message in messages:
+        if is_assistant_artifact_role(message.get('role')):
+            continue
+
         metadata = message.get('metadata', {}) or {}
         if metadata.get('is_deleted') is True:
             continue
diff --git a/application/single_app/route_backend_conversations.py b/application/single_app/route_backend_conversations.py
index 8473179f..23f1a071 100644
--- a/application/single_app/route_backend_conversations.py
+++ b/application/single_app/route_backend_conversations.py
@@ -8,6 +8,7 @@
 from functions_notifications import mark_chat_response_notifications_read_for_conversation
 from flask import Response, request
 from functions_debug import debug_print
+from functions_message_artifacts import filter_assistant_artifact_items
 from swagger_wrapper import swagger_route, get_auth_security
 from functions_activity_logging import log_conversation_creation, log_conversation_deletion, log_conversation_archival
 from functions_thoughts import archive_thoughts_for_conversation, delete_thoughts_for_conversation
@@ -37,6 +38,40 @@ def normalize_chat_type(conversation_item):
     conversation_item['chat_type'] = chat_type
     return chat_type, True
 
+
+def _collect_child_message_documents(conversation_id, root_message_ids):
+    """Collect child records linked by parent_message_id for the provided message ids."""
+    pending_ids = [message_id for message_id in root_message_ids if message_id]
+    seen_ids = set(pending_ids)
+    child_docs = []
+
+    while pending_ids:
+        parent_message_id = pending_ids.pop(0)
+        child_query = (
+            "SELECT * FROM c "
+            "WHERE c.conversation_id = @conversation_id "
+            "AND c.parent_message_id = @parent_message_id"
+        )
+        child_results = list(cosmos_messages_container.query_items(
+            query=child_query,
+            parameters=[
+                {'name': '@conversation_id', 'value': conversation_id},
+                {'name': '@parent_message_id', 'value': parent_message_id},
+            ],
+            partition_key=conversation_id,
+        ))
+
+        for child_doc in child_results:
+            child_id = child_doc.get('id')
+            if not child_id or child_id in seen_ids:
+                continue
+
+            seen_ids.add(child_id)
+            child_docs.append(child_doc)
+            pending_ids.append(child_id)
+
+    return child_docs
+
 def register_route_backend_conversations(app):
 
     @app.route('/api/get_messages', methods=['GET'])
@@ -69,6 +104,7 @@ def api_get_messages():
                 query=message_query,
                 partition_key=conversation_id
             ))
+            all_items = filter_assistant_artifact_items(all_items)
             
             debug_print(f"Query returned {len(all_items)} total items (before filtering)")
             
@@ -949,6 +985,7 @@ def generate_conversation_summary_api(conversation_id):
                 parameters=params,
                 enable_cross_partition_query=True
             ))
+            raw_messages = filter_assistant_artifact_items(raw_messages)
         except Exception as e:
             debug_print(f"Error querying messages for summary: {e}")
             return jsonify({'error': 'Failed to query messages'}), 500
@@ -1500,6 +1537,13 @@ def delete_message(message_id):
             else:
                 # Delete only the specified message
                 messages_to_delete = [message_doc]
+
+            child_message_docs = _collect_child_message_documents(
+                conversation_id,
+                [message.get('id') for message in messages_to_delete],
+            )
+            if child_message_docs:
+                messages_to_delete.extend(child_message_docs)
             
             # THREAD ATTEMPT PROMOTION: If deleting an active thread attempt, promote next attempt
             if messages_to_delete:
diff --git a/application/single_app/route_backend_plugins.py b/application/single_app/route_backend_plugins.py
index f958b10e..a9057dba 100644
--- a/application/single_app/route_backend_plugins.py
+++ b/application/single_app/route_backend_plugins.py
@@ -37,7 +37,7 @@
 #from functions_personal_actions import delete_personal_action
 
 from functions_debug import debug_print
-from json_schema_validation import validate_plugin
+from json_schema_validation import PLUGIN_STORAGE_MANAGED_FIELDS, validate_plugin
 from functions_activity_logging import (
     log_action_creation,
     log_action_update,
@@ -347,11 +347,9 @@ def set_user_plugins():
         plugin.setdefault('metadata', {})
         plugin.setdefault('additionalFields', {})
         
-        # Remove Cosmos DB system fields that are not part of the plugin schema
-        cosmos_fields = ['_attachments', '_etag', '_rid', '_self', '_ts', 'created_at', 'updated_at', 'user_id', 'last_updated']
-        for field in cosmos_fields:
-            if field in plugin:
-                del plugin[field]
+        # Remove storage-managed fields that are not part of the plugin manifest schema.
+        for field in PLUGIN_STORAGE_MANAGED_FIELDS:
+            plugin.pop(field, None)
         
         # Handle endpoint based on plugin type
         plugin_type = plugin.get('type', '')
diff --git a/application/single_app/route_frontend_conversations.py b/application/single_app/route_frontend_conversations.py
index a5d3f261..4ffc2371 100644
--- a/application/single_app/route_frontend_conversations.py
+++ b/application/single_app/route_frontend_conversations.py
@@ -4,6 +4,7 @@
 from functions_authentication import *
 from functions_debug import debug_print
 from functions_chat import sort_messages_by_thread
+from functions_message_artifacts import filter_assistant_artifact_items
 from swagger_wrapper import swagger_route, get_auth_security
 
 def register_route_frontend_conversations(app):
@@ -53,6 +54,7 @@ def view_conversation(conversation_id):
             query=message_query,
             partition_key=conversation_id
         ))
+        messages = filter_assistant_artifact_items(messages)
         return render_template('chat.html', conversation_id=conversation_id, messages=messages)
     
     @app.route('/conversation/<conversation_id>/messages', methods=['GET'])
@@ -78,6 +80,7 @@ def get_conversation_messages(conversation_id):
             query=msg_query,
             partition_key=conversation_id
         ))
+        all_items = filter_assistant_artifact_items(all_items)
 
         debug_print(f"Frontend endpoint - Query returned {len(all_items)} total items (before filtering)")
         
diff --git a/application/single_app/static/js/admin/admin_plugins.js b/application/single_app/static/js/admin/admin_plugins.js
index ad497f62..97dc39ec 100644
--- a/application/single_app/static/js/admin/admin_plugins.js
+++ b/application/single_app/static/js/admin/admin_plugins.js
@@ -1,6 +1,6 @@
 // admin_plugins.js (updated to use new multi-step modal)
 import { showToast } from "../chat/chat-toast.js"
-import { renderPluginsTable as sharedRenderPluginsTable, validatePluginManifest as sharedValidatePluginManifest } from "../plugin_common.js";
+import { renderPluginsTable as sharedRenderPluginsTable, validatePluginManifest as sharedValidatePluginManifest, getErrorMessageFromResponse } from "../plugin_common.js";
 
 // Main logic
 document.addEventListener('DOMContentLoaded', function () {
@@ -65,9 +65,11 @@ function setupSaveHandler(plugin, modal) {
                 const formData = window.pluginModalStepper.getFormData();
                 
                 // Validate with JSON schema
-                const valid = await sharedValidatePluginManifest(formData);
-                if (!valid) {
-                    window.pluginModalStepper.showError('Validation error: Invalid action data.');
+                const validation = await sharedValidatePluginManifest(formData);
+                const validationFailed = validation === false || (validation && validation.valid === false);
+                if (validationFailed) {
+                    const message = validation?.errors?.join('\n') || 'Validation error: Invalid action data.';
+                    window.pluginModalStepper.showError(message);
                     return;
                 }
                 
@@ -118,8 +120,8 @@ async function savePlugin(pluginData, existingPlugin = null) {
     });
     
     if (!saveRes.ok) {
-        const errorText = await saveRes.text();
-        throw new Error(`Failed to save action: ${errorText}`);
+        const errorMessage = await getErrorMessageFromResponse(saveRes, 'Failed to save action');
+        throw new Error(errorMessage);
     }
 }
 
diff --git a/application/single_app/static/js/admin/admin_plugins_new.js b/application/single_app/static/js/admin/admin_plugins_new.js
index 93c7a926..9d378d43 100644
--- a/application/single_app/static/js/admin/admin_plugins_new.js
+++ b/application/single_app/static/js/admin/admin_plugins_new.js
@@ -1,6 +1,6 @@
 // admin_plugins.js (updated to use new multi-step modal)
 import { showToast } from "../chat/chat-toast.js"
-import { renderPluginsTable as sharedRenderPluginsTable, validatePluginManifest as sharedValidatePluginManifest } from "../plugin_common.js";
+import { renderPluginsTable as sharedRenderPluginsTable, validatePluginManifest as sharedValidatePluginManifest, getErrorMessageFromResponse } from "../plugin_common.js";
 
 // Main logic
 document.addEventListener('DOMContentLoaded', function () {
@@ -61,9 +61,11 @@ function setupSaveHandler(plugin, modal) {
                 const formData = window.pluginModalStepper.getFormData();
                 
                 // Validate with JSON schema
-                const valid = await sharedValidatePluginManifest(formData);
-                if (!valid) {
-                    window.pluginModalStepper.showError('Validation error: Invalid action data.');
+                const validation = await sharedValidatePluginManifest(formData);
+                const validationFailed = validation === false || (validation && validation.valid === false);
+                if (validationFailed) {
+                    const message = validation?.errors?.join('\n') || 'Validation error: Invalid action data.';
+                    window.pluginModalStepper.showError(message);
                     return;
                 }
                 
@@ -103,8 +105,8 @@ async function savePlugin(pluginData, existingPlugin = null) {
     });
     
     if (!saveRes.ok) {
-        const errorText = await saveRes.text();
-        throw new Error(`Failed to save action: ${errorText}`);
+        const errorMessage = await getErrorMessageFromResponse(saveRes, 'Failed to save action');
+        throw new Error(errorMessage);
     }
 }
 
diff --git a/application/single_app/static/js/plugin_common.js b/application/single_app/static/js/plugin_common.js
index 29a88a24..e50278d4 100644
--- a/application/single_app/static/js/plugin_common.js
+++ b/application/single_app/static/js/plugin_common.js
@@ -331,6 +331,20 @@ export async function validatePluginManifest(pluginManifest) {
   return await validatePluginManifestServerSide(pluginManifest);
 }
 
+export async function getErrorMessageFromResponse(response, fallbackMessage = 'Request failed') {
+  const responseText = await response.text();
+  if (!responseText) {
+    return fallbackMessage;
+  }
+
+  try {
+    const errorData = JSON.parse(responseText);
+    return errorData.error || responseText;
+  } catch (error) {
+    return responseText;
+  }
+}
+
 // Server-side validation fallback
 async function validatePluginManifestServerSide(pluginManifest) {
   try {
diff --git a/application/single_app/static/js/workspace/workspace_plugins.js b/application/single_app/static/js/workspace/workspace_plugins.js
index 8ed4f6b5..67a7a966 100644
--- a/application/single_app/static/js/workspace/workspace_plugins.js
+++ b/application/single_app/static/js/workspace/workspace_plugins.js
@@ -1,5 +1,5 @@
 // workspace_plugins.js (refactored to use plugin_common.js and new multi-step modal)
-import { renderPluginsTable, renderPluginsGrid, ensurePluginsTableInRoot, validatePluginManifest } from '../plugin_common.js';
+import { renderPluginsTable, renderPluginsGrid, ensurePluginsTableInRoot, validatePluginManifest, getErrorMessageFromResponse } from '../plugin_common.js';
 import { showToast } from "../chat/chat-toast.js"
 import {
     setupViewToggle, switchViewContainers, openViewModal
@@ -136,9 +136,11 @@ function setupSaveHandler(plugin, modal) {
         const formData = window.pluginModalStepper.getFormData();
         
         // Validate with JSON schema
-        const valid = await validatePluginManifest(formData);
-        if (!valid) {
-          window.pluginModalStepper.showError('Validation error: Invalid action data.');
+        const validation = await validatePluginManifest(formData);
+        const validationFailed = validation === false || (validation && validation.valid === false);
+        if (validationFailed) {
+          const message = validation?.errors?.join('\n') || 'Validation error: Invalid action data.';
+          window.pluginModalStepper.showError(message);
           return;
         }
         
@@ -208,7 +210,8 @@ async function savePlugin(pluginData, existingPlugin = null) {
   });
   
   if (!saveRes.ok) {
-    throw new Error('Failed to save action');
+    const errorMessage = await getErrorMessageFromResponse(saveRes, 'Failed to save action');
+    throw new Error(errorMessage);
   }
 }
 
diff --git a/application/single_app/static/js/workspace/workspace_plugins_new.js b/application/single_app/static/js/workspace/workspace_plugins_new.js
index 509e53e8..3a213ebb 100644
--- a/application/single_app/static/js/workspace/workspace_plugins_new.js
+++ b/application/single_app/static/js/workspace/workspace_plugins_new.js
@@ -1,5 +1,5 @@
 // workspace_plugins.js (refactored to use plugin_common.js and new multi-step modal)
-import { renderPluginsTable, ensurePluginsTableInRoot, validatePluginManifest } from '../plugin_common.js';
+import { renderPluginsTable, ensurePluginsTableInRoot, validatePluginManifest, getErrorMessageFromResponse } from '../plugin_common.js';
 import { showToast } from "../chat/chat-toast.js"
 
 const root = document.getElementById('workspace-plugins-root');
@@ -68,9 +68,11 @@ function setupSaveHandler(plugin, modal) {
         const formData = window.pluginModalStepper.getFormData();
         
         // Validate with JSON schema
-        const valid = await validatePluginManifest(formData);
-        if (!valid) {
-          window.pluginModalStepper.showError('Validation error: Invalid action data.');
+        const validation = await validatePluginManifest(formData);
+        const validationFailed = validation === false || (validation && validation.valid === false);
+        if (validationFailed) {
+          const message = validation?.errors?.join('\n') || 'Validation error: Invalid action data.';
+          window.pluginModalStepper.showError(message);
           return;
         }
         
@@ -118,7 +120,8 @@ async function savePlugin(pluginData, existingPlugin = null) {
   });
   
   if (!saveRes.ok) {
-    throw new Error('Failed to save action');
+    const errorMessage = await getErrorMessageFromResponse(saveRes, 'Failed to save action');
+    throw new Error(errorMessage);
   }
 }
 
diff --git a/docs/explanation/fixes/ASSISTANT_CITATION_ARTIFACT_STORAGE_FIX.md b/docs/explanation/fixes/ASSISTANT_CITATION_ARTIFACT_STORAGE_FIX.md
new file mode 100644
index 00000000..6d518fd4
--- /dev/null
+++ b/docs/explanation/fixes/ASSISTANT_CITATION_ARTIFACT_STORAGE_FIX.md
@@ -0,0 +1,54 @@
+# Assistant Citation Artifact Storage Fix
+
+Fixed/Implemented in version: **0.240.013**
+
+Related config.py update: `VERSION = "0.240.013"`
+
+## Issue Description
+
+Large tool-backed chat responses could exceed Azure Cosmos DB item limits because the assistant message document stored the final answer together with full raw agent citation payloads, including large tabular result sets.
+
+## Root Cause Analysis
+
+- The primary `messages` container stores assistant replies as a single item partitioned by `conversation_id`.
+- Assistant documents embedded full `agent_citations` payloads directly on the main message record.
+- Tabular tool citations could include large `function_result` payloads with many returned rows, so several successful tabular calls could push a single assistant message over Cosmos DB's 2 MB per-item limit.
+
+## Technical Details
+
+### Files Modified
+
+- `application/single_app/functions_message_artifacts.py`
+- `application/single_app/route_backend_chats.py`
+- `application/single_app/route_backend_conversations.py`
+- `application/single_app/route_frontend_conversations.py`
+- `application/single_app/route_backend_conversation_export.py`
+- `application/single_app/config.py`
+- `functional_tests/test_assistant_citation_artifact_storage.py`
+
+### Code Changes Summary
+
+- Added dedicated helper functions for compacting agent citations, storing full raw citation payloads as linked assistant artifact records, and rehydrating those payloads for exports.
+- Updated both the regular chat route and the streaming chat route to persist compact `agent_citations` on the assistant message while moving the full raw citation payloads into child records in the same conversation partition.
+- Removed the duplicate `user_message` field from assistant message documents to reduce message size further.
+- Excluded assistant artifact records from visible chat history and summary assembly so they do not pollute normal conversation transcripts.
+- Updated message deletion to cascade into child records linked through `parent_message_id`, which also prevents orphaned assistant artifact records.
+- Updated conversation export hydration so exported assistant messages can still include the preserved raw citation payloads.
+
+### Testing Approach
+
+- Functional regression: `functional_tests/test_assistant_citation_artifact_storage.py`
+
+## Validation
+
+### Before
+
+- Assistant messages embedded full raw agent citation payloads directly in the main chat item.
+- Large tabular citation results could make the final assistant message exceed Cosmos DB item limits.
+- Export and chat history logic had no dedicated concept of linked assistant-side artifact records.
+
+### After
+
+- Assistant messages store compact citation summaries with linked artifact references.
+- Full raw citation payloads are preserved in linked child records rather than on the main assistant message.
+- Chat history and summarization exclude the assistant artifact records, while export logic can rehydrate the full raw payloads from those linked records.
\ No newline at end of file
diff --git a/docs/explanation/fixes/TABULAR_PROMPT_BUDGET_FALLBACK_FIX.md b/docs/explanation/fixes/TABULAR_PROMPT_BUDGET_FALLBACK_FIX.md
new file mode 100644
index 00000000..26dfb4db
--- /dev/null
+++ b/docs/explanation/fixes/TABULAR_PROMPT_BUDGET_FALLBACK_FIX.md
@@ -0,0 +1,46 @@
+# Tabular Prompt Budget Fallback Fix
+
+Fixed/Implemented in version: **0.240.013**
+
+Related config.py update: `VERSION = "0.240.013"`
+
+## Issue Description
+
+Large tabular tool results could still overflow the outer model handoff budget even after successful tool execution, because the fallback synthesis path was serializing too many full sample rows and large cell values into the computed-results prompt.
+
+## Root Cause Analysis
+
+- The fallback path in `route_backend_chats.py` relied on compact summaries, but row samples and overlap summaries could still carry very large cell values.
+- Prompt-fit checks were based on structural limits only, so repeated large row payloads could still produce an oversized handoff or a fallback that lacked a clear truncation signal.
+- The computed-results rescue path needed deterministic compaction so successful tabular evidence stayed usable without recreating the original request-size problem.
+
+## Technical Details
+
+### Files Modified
+
+- `application/single_app/route_backend_chats.py`
+- `application/single_app/config.py`
+- `functional_tests/test_tabular_raw_tool_fallback.py`
+
+### Code Changes Summary
+
+- Added prompt-safe compaction for tabular fallback values so long cell content is truncated before overlap summaries or tool result summaries are serialized.
+- Updated compact fallback payload generation to mark `result_summary_truncated` when row content was shortened for the prompt budget.
+- Kept the computed-results handoff cap and prompt-budget regression coverage in place so large tabular fallbacks remain bounded.
+
+### Testing Approach
+
+- Functional regression: `functional_tests/test_tabular_raw_tool_fallback.py`
+
+## Validation
+
+### Before
+
+- Large row payloads could dominate the fallback summary even after other prompt-budget safeguards were added.
+- The fallback regression for large rows could still fail, or the fallback could fit only without an explicit truncation signal.
+
+### After
+
+- Overlap summaries and tool result summaries compact large cell values before prompt serialization.
+- Large raw fallback summaries stay within the regression budget and explicitly indicate truncation when compaction was required.
+- Successful tabular tool executions remain available as computed evidence even when the inner synthesis step fails.
\ No newline at end of file
diff --git a/docs/explanation/fixes/WORKSPACE_PLUGIN_VALIDATION_AUDIT_FIELDS_FIX.md b/docs/explanation/fixes/WORKSPACE_PLUGIN_VALIDATION_AUDIT_FIELDS_FIX.md
new file mode 100644
index 00000000..3d4e6541
--- /dev/null
+++ b/docs/explanation/fixes/WORKSPACE_PLUGIN_VALIDATION_AUDIT_FIELDS_FIX.md
@@ -0,0 +1,53 @@
+# Workspace Plugin Validation Audit Fields Fix
+
+Fixed/Implemented in version: **0.240.011**
+
+## Issue Description
+
+Saving a new personal workspace action could fail with a generic `Failed to save action` message even when the new manifest itself was valid. In the reported case, this surfaced while saving a new Microsoft Graph action.
+
+## Root Cause Analysis
+
+- The personal workspace action editor reloads the full existing action list and posts that list back to `/api/user/plugins` on save.
+- Persisted action documents include storage-managed audit fields such as `created_by`, `modified_by`, and `modified_at`.
+- `validate_plugin()` only stripped a narrow set of Cosmos metadata fields, so those audit fields caused validation to fail before the new action was saved.
+- The workspace and admin modal save handlers also collapsed backend errors into a generic message, which hid the real failure reason from the user.
+
+## Technical Details
+
+### Files Modified
+
+- `application/single_app/json_schema_validation.py`
+- `application/single_app/route_backend_plugins.py`
+- `application/single_app/static/js/plugin_common.js`
+- `application/single_app/static/js/workspace/workspace_plugins.js`
+- `application/single_app/static/js/workspace/workspace_plugins_new.js`
+- `application/single_app/static/js/admin/admin_plugins.js`
+- `application/single_app/static/js/admin/admin_plugins_new.js`
+- `application/single_app/config.py`
+- `functional_tests/test_plugin_validation_managed_fields_compatibility.py`
+
+### Code Changes Summary
+
+- Expanded plugin validation sanitization to ignore storage-managed action fields in addition to Cosmos system metadata.
+- Updated the user action save route to strip those same storage-managed fields before validating and persisting the posted action list.
+- Added a shared client helper to extract backend error messages from failed save responses.
+- Updated workspace and admin action modal save flows to respect `validation.valid === false` and show actual backend save errors instead of a generic failure string.
+- Added a regression test that covers persisted Microsoft Graph and SQL action validation with audit fields present.
+
+### Testing Approach
+
+- Functional regression: `functional_tests/test_plugin_validation_managed_fields_compatibility.py`
+
+## Validation
+
+### Before
+
+- Any existing persisted personal action containing audit fields could block saving a new action.
+- The modal typically showed only `Failed to save action`, which obscured the real validation failure.
+
+### After
+
+- Persisted plugin audit fields no longer break validation during workspace action saves.
+- New Microsoft Graph actions can be saved without unrelated existing actions causing validation failures.
+- If a save does fail, the modal now shows the backend-provided error message.
\ No newline at end of file
diff --git a/functional_tests/test_assistant_citation_artifact_storage.py b/functional_tests/test_assistant_citation_artifact_storage.py
new file mode 100644
index 00000000..47bfd404
--- /dev/null
+++ b/functional_tests/test_assistant_citation_artifact_storage.py
@@ -0,0 +1,156 @@
+# test_assistant_citation_artifact_storage.py
+"""
+Functional test for assistant citation artifact storage.
+Version: 0.240.013
+Implemented in: 0.240.013
+
+This test ensures assistant messages keep compact agent citation summaries while
+the full raw citation payload is preserved in linked artifact records that can
+be rehydrated for exports or later analysis.
+"""
+
+import os
+import sys
+from copy import deepcopy
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+APP_ROOT = REPO_ROOT / 'application' / 'single_app'
+if str(APP_ROOT) not in sys.path:
+    sys.path.insert(0, str(APP_ROOT))
+
+from functions_message_artifacts import (  # noqa: E402
+    ASSISTANT_ARTIFACT_CHUNK_ROLE,
+    ASSISTANT_ARTIFACT_ROLE,
+    build_agent_citation_artifact_documents,
+    build_message_artifact_payload_map,
+    filter_assistant_artifact_items,
+    hydrate_agent_citations_from_artifacts,
+)
+
+
+CONFIG_FILE = APP_ROOT / 'config.py'
+ROUTE_FILE = APP_ROOT / 'route_backend_chats.py'
+
+
+def build_sample_tabular_citation(row_count=12):
+    """Return a representative tabular citation with enough rows to compact."""
+    rows = []
+    for index in range(row_count):
+        rows.append({
+            'TaxpayerID': f'TP{index:06d}',
+            'Name': f'Taxpayer {index}',
+            'Status': 'Active' if index % 2 == 0 else 'Closed',
+            'NoticeAmount': 1000 + index,
+            'NoticeDate': f'2026-03-{(index % 28) + 1:02d}',
+        })
+
+    return {
+        'tool_name': 'TabularProcessingPlugin.filter_rows',
+        'function_name': 'filter_rows',
+        'plugin_name': 'TabularProcessingPlugin',
+        'function_arguments': {
+            'user_id': 'user-123',
+            'conversation_id': 'conversation-456',
+            'filename': 'irs_treasury_multi_tab_workbook.xlsx',
+            'sheet_name': 'Notices',
+            'column': 'TaxpayerID',
+            'operator': '==',
+            'value': 'TP000123',
+            'max_rows': '25',
+            'source': 'workspace',
+        },
+        'function_result': {
+            'filename': 'irs_treasury_multi_tab_workbook.xlsx',
+            'selected_sheet': 'Notices',
+            'total_matches': row_count,
+            'returned_rows': row_count,
+            'data': rows,
+        },
+        'duration_ms': 42.5,
+        'timestamp': '2026-04-01T00:00:00Z',
+        'success': True,
+        'error_message': None,
+    }
+
+
+def test_agent_citation_artifacts_keep_parent_message_compact():
+    """Verify compact citations retain references while raw payloads move to artifact docs."""
+    citation = build_sample_tabular_citation(row_count=12)
+    compact_citations, artifact_docs = build_agent_citation_artifact_documents(
+        conversation_id='conversation-456',
+        assistant_message_id='conversation-456_assistant_1',
+        agent_citations=[citation],
+        created_timestamp='2026-04-01T00:00:00Z',
+        user_info={'user_id': 'user-123'},
+    )
+
+    assert len(compact_citations) == 1, compact_citations
+    assert artifact_docs, 'Expected raw citation artifact documents to be created.'
+    assert artifact_docs[0]['role'] == ASSISTANT_ARTIFACT_ROLE, artifact_docs[0]
+    assert compact_citations[0]['artifact_id'] == 'conversation-456_assistant_1_artifact_1', compact_citations[0]
+    assert compact_citations[0]['raw_payload_externalized'] is True, compact_citations[0]
+    assert compact_citations[0]['function_result']['total_matches'] == 12, compact_citations[0]
+    assert compact_citations[0]['function_result']['returned_rows'] == 12, compact_citations[0]
+    assert len(compact_citations[0]['function_result']['sample_rows']) == 3, compact_citations[0]
+    assert compact_citations[0]['function_result']['sample_rows_limited'] is True, compact_citations[0]
+    assert 'user_id' not in compact_citations[0]['function_arguments'], compact_citations[0]
+    assert 'conversation_id' not in compact_citations[0]['function_arguments'], compact_citations[0]
+
+
+def test_artifact_payloads_rehydrate_full_agent_citations():
+    """Verify export hydration restores the preserved raw payload from artifact docs."""
+    citation = build_sample_tabular_citation(row_count=9)
+    compact_citations, artifact_docs = build_agent_citation_artifact_documents(
+        conversation_id='conversation-789',
+        assistant_message_id='conversation-789_assistant_1',
+        agent_citations=[citation],
+        created_timestamp='2026-04-01T00:00:00Z',
+    )
+
+    artifact_payload_map = build_message_artifact_payload_map(artifact_docs)
+    hydrated_messages = hydrate_agent_citations_from_artifacts([
+        {
+            'id': 'conversation-789_assistant_1',
+            'role': 'assistant',
+            'agent_citations': deepcopy(compact_citations),
+        }
+    ], artifact_payload_map)
+
+    hydrated_citation = hydrated_messages[0]['agent_citations'][0]
+    assert hydrated_citation['function_name'] == 'filter_rows', hydrated_citation
+    assert hydrated_citation['plugin_name'] == 'TabularProcessingPlugin', hydrated_citation
+    assert len(hydrated_citation['function_result']['data']) == 9, hydrated_citation
+    assert hydrated_citation['function_result']['data'][0]['TaxpayerID'] == 'TP000000', hydrated_citation
+
+
+def test_filter_assistant_artifact_items_excludes_child_records():
+    """Verify assistant artifact docs stay out of visible chat histories."""
+    visible_items = filter_assistant_artifact_items([
+        {'id': 'assistant-1', 'role': 'assistant'},
+        {'id': 'artifact-1', 'role': ASSISTANT_ARTIFACT_ROLE},
+        {'id': 'artifact-1_chunk_1', 'role': ASSISTANT_ARTIFACT_CHUNK_ROLE},
+        {'id': 'user-1', 'role': 'user'},
+    ])
+
+    visible_ids = [item['id'] for item in visible_items]
+    assert visible_ids == ['assistant-1', 'user-1'], visible_ids
+
+
+def test_config_and_route_reference_phase_one_storage_fix():
+    """Verify the application version and route integration reflect phase one."""
+    config_content = CONFIG_FILE.read_text(encoding='utf-8')
+    route_content = ROUTE_FILE.read_text(encoding='utf-8')
+
+    assert 'VERSION = "0.240.013"' in config_content, 'Expected config.py version 0.240.013'
+    assert 'persist_agent_citation_artifacts(' in route_content, 'Expected chat routes to persist citation artifacts.'
+    assert 'filter_assistant_artifact_items(all_messages)' in route_content, 'Expected chat history assembly to exclude assistant artifact docs.'
+
+
+if __name__ == '__main__':
+    test_agent_citation_artifacts_keep_parent_message_compact()
+    test_artifact_payloads_rehydrate_full_agent_citations()
+    test_filter_assistant_artifact_items_excludes_child_records()
+    test_config_and_route_reference_phase_one_storage_fix()
+    print('✅ Assistant citation artifact storage verified.')
\ No newline at end of file
diff --git a/functional_tests/test_plugin_validation_managed_fields_compatibility.py b/functional_tests/test_plugin_validation_managed_fields_compatibility.py
new file mode 100644
index 00000000..3f00f0bd
--- /dev/null
+++ b/functional_tests/test_plugin_validation_managed_fields_compatibility.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# test_plugin_validation_managed_fields_compatibility.py
+"""
+Functional test for persisted plugin validation managed-field compatibility.
+Version: 0.240.011
+Implemented in: 0.240.011
+
+This test ensures storage-managed audit fields on persisted plugin documents do not
+block validation during workspace action saves, while endpoint rules remain enforced.
+"""
+
+import os
+import sys
+
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(REPO_ROOT, 'application', 'single_app'))
+
+
+def test_persisted_msgraph_plugin_validation():
+    """Persisted Microsoft Graph plugins should remain validation-safe."""
+    print('🔍 Testing persisted MS Graph plugin validation...')
+
+    try:
+        from json_schema_validation import validate_plugin
+
+        plugin = {
+            'name': 'msgraph',
+            'displayName': 'MSGraph',
+            'type': 'msgraph',
+            'description': 'Microsoft Graph action for user-scoped operations.',
+            'endpoint': 'https://graph.microsoft.com/',
+            'auth': {'type': 'user'},
+            'metadata': {},
+            'additionalFields': {},
+            'created_by': 'user-123',
+            'modified_by': 'user-123',
+            'modified_at': '2026-04-01T12:00:00Z',
+        }
+
+        validation_error = validate_plugin(plugin)
+        if validation_error:
+            print(f'❌ Persisted MS Graph plugin validation failed: {validation_error}')
+            return False
+
+        print('✅ Persisted MS Graph plugin validation passed!')
+        return True
+    except Exception as exc:
+        print(f'❌ Persisted MS Graph plugin validation test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_persisted_sql_plugin_validation():
+    """Persisted SQL plugins should remain validation-safe with audit fields present."""
+    print('🔍 Testing persisted SQL plugin validation...')
+
+    try:
+        from json_schema_validation import validate_plugin
+
+        plugin = {
+            'name': 'workforce_compensation_schema',
+            'displayName': 'Workforce Compensation Schema',
+            'type': 'sql_schema',
+            'description': 'Schema plugin for workforce compensation data.',
+            'endpoint': '',
+            'auth': {'type': 'user'},
+            'metadata': {},
+            'additionalFields': {
+                'database_type': 'azure_sql',
+                'server': 'retroburnsqldemo.database.windows.net',
+                'database': 'WorkforceCompensation',
+            },
+            'created_by': 'user-123',
+            'modified_by': 'user-123',
+            'modified_at': '2026-04-01T12:00:00Z',
+        }
+
+        validation_error = validate_plugin(plugin)
+        if validation_error:
+            print(f'❌ Persisted SQL plugin validation failed: {validation_error}')
+            return False
+
+        print('✅ Persisted SQL plugin validation passed!')
+        return True
+    except Exception as exc:
+        print(f'❌ Persisted SQL plugin validation test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_non_sql_endpoint_requirement_still_applies():
+    """Non-SQL plugins should still fail when the endpoint is missing."""
+    print('🔍 Testing non-SQL endpoint enforcement with managed fields...')
+
+    try:
+        from json_schema_validation import validate_plugin
+
+        plugin = {
+            'name': 'custom_plugin',
+            'displayName': 'Custom Plugin',
+            'type': 'custom',
+            'description': 'Generic plugin without an endpoint.',
+            'endpoint': '',
+            'auth': {'type': 'user'},
+            'metadata': {},
+            'additionalFields': {},
+            'created_by': 'user-123',
+            'modified_by': 'user-123',
+            'modified_at': '2026-04-01T12:00:00Z',
+        }
+
+        validation_error = validate_plugin(plugin)
+        if not validation_error:
+            print('❌ Non-SQL plugin without an endpoint should have failed validation!')
+            return False
+
+        if 'valid endpoint' not in validation_error:
+            print(f'❌ Unexpected validation error: {validation_error}')
+            return False
+
+        print(f'✅ Non-SQL endpoint requirement correctly enforced: {validation_error}')
+        return True
+    except Exception as exc:
+        print(f'❌ Non-SQL endpoint enforcement test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == '__main__':
+    print('🧪 Running persisted plugin validation managed-field compatibility tests...\n')
+
+    tests = [
+        test_persisted_msgraph_plugin_validation,
+        test_persisted_sql_plugin_validation,
+        test_non_sql_endpoint_requirement_still_applies,
+    ]
+    results = []
+
+    for test in tests:
+        print(f'\n🧪 Running {test.__name__}...')
+        results.append(test())
+
+    success = all(results)
+    print(f'\n📊 Results: {sum(results)}/{len(results)} tests passed')
+    sys.exit(0 if success else 1)
\ No newline at end of file
diff --git a/functional_tests/test_tabular_raw_tool_fallback.py b/functional_tests/test_tabular_raw_tool_fallback.py
index a8aaa736..ea405155 100644
--- a/functional_tests/test_tabular_raw_tool_fallback.py
+++ b/functional_tests/test_tabular_raw_tool_fallback.py
@@ -2,8 +2,8 @@
 # test_tabular_raw_tool_fallback.py
 """
 Functional test for tabular raw tool fallback summaries.
-Version: 0.239.125
-Implemented in: 0.239.125
+Version: 0.240.013
+Implemented in: 0.239.125; 0.240.013 (prompt-budgeted fallback handoff)
 
 This test ensures successful tabular tool calls are not discarded when the
 inner tabular synthesis step fails, and that the analysis prompt now prefers
@@ -22,6 +22,7 @@
 
 ROUTE_FILE = os.path.join(ROOT_DIR, 'application', 'single_app', 'route_backend_chats.py')
 TARGET_FUNCTIONS = {
+    'build_tabular_computed_results_system_message',
     'get_tabular_invocation_result_payload',
     'get_tabular_invocation_error_message',
     'get_tabular_invocation_selected_sheet',
@@ -29,6 +30,7 @@
     'normalize_tabular_overlap_value',
     'get_tabular_overlap_identifier_column',
     'describe_tabular_invocation_conditions',
+    'compact_tabular_fallback_value',
     'get_tabular_query_overlap_summary',
     'get_tabular_invocation_compact_payload',
     'build_tabular_analysis_fallback_from_invocations',
@@ -289,11 +291,90 @@ def test_route_prompt_prefers_combined_queries_and_raw_fallback_helper():
         return False
 
 
+def test_raw_fallback_stays_within_prompt_budget_for_large_rows():
+    """Verify oversized fallback payloads are reduced to a bounded handoff."""
+    print('🔍 Testing raw fallback prompt budget...')
+
+    try:
+        helpers, _ = load_fallback_helpers()
+        build_fallback = helpers['build_tabular_analysis_fallback_from_invocations']
+
+        large_cell = 'X' * 5000
+        large_rows = {
+            'filename': 'large_workbook.xlsx',
+            'selected_sheet': 'Notices',
+            'total_matches': 12,
+            'returned_rows': 12,
+            'data': [
+                {
+                    'TaxpayerID': f'TP{index:06d}',
+                    'Narrative': large_cell,
+                    'NoticeAmount': 1000 + index,
+                }
+                for index in range(12)
+            ],
+        }
+
+        invocations = [
+            FakeInvocation(
+                'filter_rows',
+                {
+                    'filename': 'large_workbook.xlsx',
+                    'column': 'TaxpayerID',
+                    'operator': 'contains',
+                    'value': 'TP',
+                },
+                json.dumps(large_rows),
+            )
+            for _ in range(4)
+        ]
+
+        fallback_summary = build_fallback(invocations)
+
+        assert fallback_summary is not None, 'Expected raw fallback summary'
+        assert len(fallback_summary) <= 26000, len(fallback_summary)
+        assert 'RESULT COVERAGE NOTE:' in fallback_summary or 'result_summary_truncated' in fallback_summary, fallback_summary
+
+        print('✅ Raw fallback prompt budget passed')
+        return True
+
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_computed_results_system_message_truncates_large_handoffs():
+    """Verify computed-results handoffs are capped before the outer model call."""
+    print('🔍 Testing computed-results handoff truncation...')
+
+    try:
+        helpers, _ = load_fallback_helpers()
+        build_system_message = helpers['build_tabular_computed_results_system_message']
+
+        message = build_system_message('the file workbook.xlsx', 'A' * 30000)
+
+        assert len(message) <= 25000, len(message)
+        assert '[Computed results handoff truncated for prompt budget.]' in message, message
+
+        print('✅ Computed-results handoff truncation passed')
+        return True
+
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
 if __name__ == '__main__':
     tests = [
         test_raw_fallback_builds_overlap_summary_from_successful_queries,
         test_raw_fallback_preserves_aggregate_and_group_summaries,
         test_route_prompt_prefers_combined_queries_and_raw_fallback_helper,
+        test_raw_fallback_stays_within_prompt_budget_for_large_rows,
+        test_computed_results_system_message_truncates_large_handoffs,
     ]
 
     results = []

From a07ec94e9837c262ebef7ddcb844c7d7e283f771 Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 07:52:41 -0400
Subject: [PATCH 04/12] Pinned python packages to an explicit version

---
 .../external_apps/bulkloader/requirements.txt |  7 +++---
 .../databaseseeder/requirements.txt           |  8 +++----
 application/single_app/config.py              |  2 +-
 application/single_app/requirements.txt       | 22 +++++++++----------
 deployers/bicep/requirements.txt              |  6 ++---
 docs/explanation/release_notes.md             |  9 ++++++++
 ui_tests/requirements.txt                     |  9 ++++----
 7 files changed, 35 insertions(+), 28 deletions(-)

diff --git a/application/external_apps/bulkloader/requirements.txt b/application/external_apps/bulkloader/requirements.txt
index e31bd339..2cee8a3b 100644
--- a/application/external_apps/bulkloader/requirements.txt
+++ b/application/external_apps/bulkloader/requirements.txt
@@ -1,4 +1,3 @@
-requests
-msal
-logging
-dotenv
\ No newline at end of file
+requests==2.32.4
+msal==1.31.0
+python-dotenv==0.21.0
\ No newline at end of file
diff --git a/application/external_apps/databaseseeder/requirements.txt b/application/external_apps/databaseseeder/requirements.txt
index 72d2766e..dfdf02ed 100644
--- a/application/external_apps/databaseseeder/requirements.txt
+++ b/application/external_apps/databaseseeder/requirements.txt
@@ -1,5 +1,3 @@
-requests
-msal
-logging
-dotenv
-flask
+requests==2.32.4
+msal==1.31.0
+python-dotenv==0.21.0
diff --git a/application/single_app/config.py b/application/single_app/config.py
index 0e55ea15..9770abf0 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.013"
+VERSION = "0.240.014"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/requirements.txt b/application/single_app/requirements.txt
index 8039c4c1..77887749 100644
--- a/application/single_app/requirements.txt
+++ b/application/single_app/requirements.txt
@@ -3,10 +3,10 @@ pandas==2.2.3
 azure-monitor-query==1.4.1
 Flask==2.2.5
 Flask-WTF==1.2.1
-gunicorn>=23.0.0
+gunicorn==25.0.3
 Werkzeug==3.1.5
 requests==2.32.4
-openai>=1.98.0
+openai==1.109.1
 docx2txt==0.8
 Markdown==3.3.4
 bleach==6.1.0
@@ -22,9 +22,9 @@ threadpoolctl==3.5.0
 azure-search-documents==11.5.3
 python-dotenv==0.21.0
 azure-ai-formrecognizer==3.3.3
-azure-ai-projects>=1.0.0,<2.0.0
-azure-ai-agents>=1.0.0
-pyjwt>=2.9.0
+azure-ai-projects==1.0.0
+azure-ai-agents==1.2.0b6
+pyjwt==2.12.1
 markdown2==2.5.3
 azure-mgmt-cognitiveservices==13.6.0
 azure-identity==1.23.0
@@ -43,14 +43,14 @@ xlrd==2.0.1
 pillow==12.1.1
 ffmpeg-binaries-compat==1.0.1
 ffmpeg-python==0.2.0
-semantic-kernel>=1.39.4
-protobuf>=5,<6 # support for broken SK >=1.40.0 versions, can be removed once SK releases a fixed version
-redis>=5.0,<6.0
-pyodbc>=4.0.0
-PyMySQL>=1.0.0
+semantic-kernel==1.39.4
+protobuf==6.33.5
+redis==5.3.1
+pyodbc==5.3.0
+PyMySQL==1.1.2
 azure-monitor-opentelemetry==1.6.13
 psycopg2-binary==2.9.10
-cython
+cython==3.2.4
 pyyaml==6.0.2
 aiohttp==3.13.3
 html2text==2025.4.15
diff --git a/deployers/bicep/requirements.txt b/deployers/bicep/requirements.txt
index e6e1fd60..aafac267 100644
--- a/deployers/bicep/requirements.txt
+++ b/deployers/bicep/requirements.txt
@@ -1,4 +1,4 @@
 # requirements.txt
-azure-identity>=1.15.0
-azure-cosmos>=4.5.0
-azure-keyvault-secrets>=4.4.0
\ No newline at end of file
+azure-identity==1.23.0
+azure-cosmos==4.9.0
+azure-keyvault-secrets==4.10.0
\ No newline at end of file
diff --git a/docs/explanation/release_notes.md b/docs/explanation/release_notes.md
index 371f2558..01ac60ba 100644
--- a/docs/explanation/release_notes.md
+++ b/docs/explanation/release_notes.md
@@ -3,6 +3,15 @@
 # Feature Release
 
 This page tracks notable Simple Chat releases and organizes the detailed change log by version. The timeline below provides a quick visual overview of the current release progression through v0.240.001, and the per-version entries continue immediately after it.
+### **(v0.240.014)**
+
+#### Bug Fixes
+
+*   **Dependency Pinning and Requirements Hardening**
+    *   Pinned previously floating Python package requirements to exact versions across the main app, UI test, deployer, and external app requirement files to reduce unexpected dependency drift and tighten supply-chain control.
+    *   Corrected stale external app dependency entries by replacing `dotenv` with `python-dotenv`, removing the stdlib-only `logging` package, removing an unused `Flask` requirement from the databaseseeder utility, and adding `pytest-playwright` so the UI test dependency set matches the pytest fixture usage in the test suite.
+    *   (Ref: `application/single_app/requirements.txt`, `ui_tests/requirements.txt`, `deployers/bicep/requirements.txt`, `application/external_apps/databaseseeder/requirements.txt`, `application/external_apps/bulkloader/requirements.txt`)
+
 ### **(v0.240.004)**
 
 #### New Features
diff --git a/ui_tests/requirements.txt b/ui_tests/requirements.txt
index e5d5c89e..06514a20 100644
--- a/ui_tests/requirements.txt
+++ b/ui_tests/requirements.txt
@@ -1,4 +1,5 @@
-pytest
-playwright
-azure-mgmt-playwright
-azure-identity
\ No newline at end of file
+pytest==9.0.2
+playwright==1.58.0
+pytest-playwright==0.7.2
+azure-mgmt-playwright==1.0.0
+azure-identity==1.23.0
\ No newline at end of file

From 8d8dfa6cdb2ea319ae7855d07a4ec2da4e14ac5c Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 08:28:09 -0400
Subject: [PATCH 05/12] updated python package versions

---
 application/single_app/config.py              |  4 +-
 application/single_app/requirements.txt       | 14 ++--
 docs/Gemfile.lock                             |  6 +-
 .../fixes/FLASK_31_MARKUP_IMPORT_FIX.md       | 50 ++++++++++++
 docs/explanation/release_notes.md             | 10 +++
 .../test_flask_markup_import_fix.py           | 80 +++++++++++++++++++
 6 files changed, 152 insertions(+), 12 deletions(-)
 create mode 100644 docs/explanation/fixes/FLASK_31_MARKUP_IMPORT_FIX.md
 create mode 100644 functional_tests/test_flask_markup_import_fix.py

diff --git a/application/single_app/config.py b/application/single_app/config.py
index 9770abf0..b2d409da 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -46,9 +46,9 @@
     session, 
     send_from_directory, 
     send_file, 
-    Markup,
     current_app
 )
+from markupsafe import Markup
 from werkzeug.utils import secure_filename
 from datetime import datetime, timezone, timedelta
 from functools import wraps
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.014"
+VERSION = "0.240.016"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/requirements.txt b/application/single_app/requirements.txt
index 77887749..a01ab60c 100644
--- a/application/single_app/requirements.txt
+++ b/application/single_app/requirements.txt
@@ -1,14 +1,14 @@
 # requirements.txt
 pandas==2.2.3
 azure-monitor-query==1.4.1
-Flask==2.2.5
+Flask==3.1.3
 Flask-WTF==1.2.1
 gunicorn==25.0.3
-Werkzeug==3.1.5
-requests==2.32.4
+Werkzeug==3.1.6
+requests==2.33.0
 openai==1.109.1
 docx2txt==0.8
-Markdown==3.3.4
+Markdown==3.8.1
 bleach==6.1.0
 azure-cosmos==4.9.0
 msal==1.31.0
@@ -25,14 +25,14 @@ azure-ai-formrecognizer==3.3.3
 azure-ai-projects==1.0.0
 azure-ai-agents==1.2.0b6
 pyjwt==2.12.1
-markdown2==2.5.3
+markdown2==2.5.5
 azure-mgmt-cognitiveservices==13.6.0
 azure-identity==1.23.0
 azure-ai-contentsafety==1.0.0
 azure-storage-blob==12.24.1
 azure-storage-queue==12.12.0
 azure-keyvault-secrets==4.10.0
-pypdf==6.4.0
+pypdf==6.9.2
 python-docx==1.1.2
 flask-executor==1.0.0
 PyMuPDF==1.25.3
@@ -52,7 +52,7 @@ azure-monitor-opentelemetry==1.6.13
 psycopg2-binary==2.9.10
 cython==3.2.4
 pyyaml==6.0.2
-aiohttp==3.13.3
+aiohttp==3.13.4
 html2text==2025.4.15
 matplotlib==3.10.7
 azure-cognitiveservices-speech==1.47.0
\ No newline at end of file
diff --git a/docs/Gemfile.lock b/docs/Gemfile.lock
index 4af17774..3eec6aff 100644
--- a/docs/Gemfile.lock
+++ b/docs/Gemfile.lock
@@ -1,7 +1,7 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (8.0.3)
+    activesupport (8.0.4.1)
       base64
       benchmark (>= 0.3)
       bigdecimal
@@ -40,7 +40,7 @@ GEM
       ffi (>= 1.15.0)
     eventmachine (1.2.7)
     execjs (2.10.0)
-    faraday (2.14.0)
+    faraday (2.14.1)
       faraday-net_http (>= 2.0, < 3.5)
       json
       logger
@@ -238,7 +238,7 @@ GEM
     minitest (5.25.5)
     net-http (0.6.0)
       uri
-    nokogiri (1.18.10-x64-mingw-ucrt)
+    nokogiri (1.19.1-x64-mingw-ucrt)
       racc (~> 1.4)
     octokit (4.25.1)
       faraday (>= 1, < 3)
diff --git a/docs/explanation/fixes/FLASK_31_MARKUP_IMPORT_FIX.md b/docs/explanation/fixes/FLASK_31_MARKUP_IMPORT_FIX.md
new file mode 100644
index 00000000..309179cb
--- /dev/null
+++ b/docs/explanation/fixes/FLASK_31_MARKUP_IMPORT_FIX.md
@@ -0,0 +1,50 @@
+# Flask 3.1 Markup Import Fix
+
+Fixed/Implemented in version: **0.240.016**
+
+## Issue Description
+
+After upgrading Flask from `2.2.5` to `3.1.3`, the application failed during startup while loading `config.py` with `ImportError: cannot import name 'Markup' from 'flask'`.
+
+## Root Cause Analysis
+
+Flask 3 no longer re-exports `Markup` from the `flask` package.
+
+The shared `config.py` module still imported `Markup` through `from flask import ...`, which caused the import failure before the app could finish initialization.
+
+## Technical Details
+
+### Files Modified
+
+- `application/single_app/config.py`
+- `functional_tests/test_flask_markup_import_fix.py`
+
+### Code Changes Summary
+
+- Removed `Markup` from the `flask` import list in `config.py`.
+- Added `from markupsafe import Markup` so the shared symbol remains available to modules that import from `config.py`.
+- Added a regression test that parses `config.py` imports and verifies the Flask 3-safe import path.
+- Bumped the application version to `0.240.016`.
+
+### Testing Approach
+
+- Added `functional_tests/test_flask_markup_import_fix.py` to verify `Markup` is imported from `markupsafe` and not from `flask`.
+- Re-ran the application startup path to validate the previous import failure is removed.
+
+## Validation
+
+### Before
+
+- `python app.py` failed immediately during `config.py` import.
+- The traceback stopped on `ImportError: cannot import name 'Markup' from 'flask'`.
+
+### After
+
+- `config.py` imports `Markup` from `markupsafe`, which is compatible with Flask 3.x.
+- The app can proceed past the previous startup import failure point.
+
+### Impact Analysis
+
+This is a narrow compatibility fix with no intended runtime behavior change.
+
+Markdown rendering and newline-to-HTML conversion continue to use the same `Markup` type, but the import source now matches the Flask 3 package boundary.
\ No newline at end of file
diff --git a/docs/explanation/release_notes.md b/docs/explanation/release_notes.md
index 01ac60ba..de15c76e 100644
--- a/docs/explanation/release_notes.md
+++ b/docs/explanation/release_notes.md
@@ -3,6 +3,16 @@
 # Feature Release
 
 This page tracks notable Simple Chat releases and organizes the detailed change log by version. The timeline below provides a quick visual overview of the current release progression through v0.240.001, and the per-version entries continue immediately after it.
+### **(v0.240.016)**
+
+#### Bug Fixes
+
+*   **Python Runtime Dependency Refresh and Supply-Chain Hardening**
+    *   Continued the requirements hardening work from `v0.240.014` by tightening the main application runtime to exact package pins, reducing dependency drift across local development, CI, and Azure deployments to help mitigate supply-chain exposure.
+    *   Upgraded the Flask runtime stack to `Flask==3.1.3` and `Werkzeug==3.1.6`, and updated the shared `Markup` import path to `markupsafe` so the app starts correctly with Flask 3's package boundary changes.
+    *   Refreshed key runtime dependencies including `gunicorn`, `requests`, `openai`, `Markdown`, `markdown2`, `azure-ai-projects`, `azure-ai-agents`, `pyjwt`, `pypdf`, `semantic-kernel`, `protobuf`, `redis`, `pyodbc`, `PyMySQL`, `cython`, and `aiohttp` to pick up current security, compatibility, and capability improvements while keeping builds reproducible.
+    *   (Ref: `application/single_app/requirements.txt`, `application/single_app/config.py`, `functional_tests/test_flask_markup_import_fix.py`, `docs/explanation/fixes/FLASK_31_MARKUP_IMPORT_FIX.md`)
+
 ### **(v0.240.014)**
 
 #### Bug Fixes
diff --git a/functional_tests/test_flask_markup_import_fix.py b/functional_tests/test_flask_markup_import_fix.py
new file mode 100644
index 00000000..acb30a0a
--- /dev/null
+++ b/functional_tests/test_flask_markup_import_fix.py
@@ -0,0 +1,80 @@
+# test_flask_markup_import_fix.py
+#!/usr/bin/env python3
+"""
+Functional test for Flask 3 Markup import compatibility.
+Version: 0.240.016
+Implemented in: 0.240.016
+
+This test ensures config.py imports Markup from markupsafe instead of flask so
+the application can start correctly on Flask 3.x.
+"""
+
+import ast
+import os
+
+
+REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+CONFIG_FILE = os.path.join(REPO_ROOT, 'application', 'single_app', 'config.py')
+FIX_DOC = os.path.join(REPO_ROOT, 'docs', 'explanation', 'fixes', 'FLASK_31_MARKUP_IMPORT_FIX.md')
+
+
+def read_file_text(file_path):
+    with open(file_path, 'r', encoding='utf-8') as file_handle:
+        return file_handle.read()
+
+
+def get_imported_names(module_ast, module_name):
+    imported_names = []
+
+    for node in ast.walk(module_ast):
+        if isinstance(node, ast.ImportFrom) and node.module == module_name:
+            imported_names.extend(alias.name for alias in node.names)
+
+    return imported_names
+
+
+def test_config_uses_markupsafe_markup_for_flask_3():
+    """Ensure config.py imports Markup from markupsafe instead of flask."""
+    print('🔍 Validating Flask 3 Markup import compatibility...')
+
+    config_content = read_file_text(CONFIG_FILE)
+    config_ast = ast.parse(config_content, filename=CONFIG_FILE)
+    flask_imports = get_imported_names(config_ast, 'flask')
+    markupsafe_imports = get_imported_names(config_ast, 'markupsafe')
+
+    assert 'Markup' not in flask_imports, (
+        'config.py must not import Markup from flask on Flask 3.x.'
+    )
+    assert 'Markup' in markupsafe_imports, (
+        'config.py should import Markup from markupsafe for Flask 3.x compatibility.'
+    )
+
+    print('✅ config.py uses the supported Markup import path')
+
+
+def test_flask_markup_fix_documentation_exists():
+    """Ensure the fix documentation records the Flask 3 compatibility change."""
+    print('🔍 Validating Flask 3 Markup fix documentation...')
+
+    fix_doc_content = read_file_text(FIX_DOC)
+
+    assert 'Fixed/Implemented in version: **0.240.016**' in fix_doc_content, (
+        'Fix documentation should reference the current implementation version.'
+    )
+    assert 'ImportError' in fix_doc_content, (
+        'Fix documentation should describe the startup import failure.'
+    )
+    assert 'markupsafe' in fix_doc_content.lower(), (
+        'Fix documentation should mention the markupsafe import path.'
+    )
+    assert 'Flask 3' in fix_doc_content, (
+        'Fix documentation should explicitly call out the Flask 3 compatibility issue.'
+    )
+
+    print('✅ Flask 3 Markup fix documentation is present')
+
+
+if __name__ == '__main__':
+    test_config_uses_markupsafe_markup_for_flask_3()
+    print()
+    test_flask_markup_fix_documentation_exists()
\ No newline at end of file

From ae34bb42166d26518d6bfdcdd9981a7ac59af5ed Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 09:07:44 -0400
Subject: [PATCH 06/12] improve multi tab joins

---
 application/single_app/config.py              |    2 +-
 .../single_app/functions_message_artifacts.py |   21 +
 application/single_app/route_backend_chats.py |   43 +-
 .../tabular_processing_plugin.py              | 1420 +++++++++++++++--
 .../TABULAR_RELATIONAL_ANALYSIS_HELPERS.md    |   95 ++
 ...est_tabular_relational_analysis_helpers.py |  306 ++++
 6 files changed, 1778 insertions(+), 109 deletions(-)
 create mode 100644 docs/explanation/features/TABULAR_RELATIONAL_ANALYSIS_HELPERS.md
 create mode 100644 functional_tests/test_tabular_relational_analysis_helpers.py

diff --git a/application/single_app/config.py b/application/single_app/config.py
index b2d409da..e5b057c1 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.016"
+VERSION = "0.240.017"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/functions_message_artifacts.py b/application/single_app/functions_message_artifacts.py
index ca2a8edc..eeda4057 100644
--- a/application/single_app/functions_message_artifacts.py
+++ b/application/single_app/functions_message_artifacts.py
@@ -301,6 +301,10 @@ def _compact_tabular_result_payload(function_name: str, payload: Any) -> Any:
     preferred_keys = [
         'filename',
         'selected_sheet',
+        'source_sheet',
+        'source_value_column',
+        'target_sheet',
+        'target_match_column',
         'lookup_column',
         'lookup_value',
         'target_column',
@@ -311,6 +315,19 @@ def _compact_tabular_result_payload(function_name: str, payload: Any) -> Any:
         'aggregate_column',
         'date_component',
         'query_expression',
+        'filter_applied',
+        'source_filter_applied',
+        'target_filter_applied',
+        'normalize_match',
+        'row_count',
+        'rows_scanned',
+        'distinct_count',
+        'returned_values',
+        'values',
+        'source_cohort_size',
+        'matched_source_value_count',
+        'unmatched_source_value_count',
+        'matched_target_row_count',
         'total_matches',
         'returned_rows',
         'groups',
@@ -397,8 +414,12 @@ def _parse_json_if_possible(value: Any) -> Any:
 def _is_tabular_citation(function_name: str, plugin_name: str) -> bool:
     return plugin_name == 'TabularProcessingPlugin' or function_name in {
         'aggregate_column',
+        'count_rows',
+        'count_rows_by_related_values',
         'describe_tabular_file',
         'filter_rows',
+        'filter_rows_by_related_values',
+        'get_distinct_values',
         'group_by_aggregate',
         'group_by_datetime_component',
         'lookup_value',
diff --git a/application/single_app/route_backend_chats.py b/application/single_app/route_backend_chats.py
index a0b46a49..e01f5b64 100644
--- a/application/single_app/route_backend_chats.py
+++ b/application/single_app/route_backend_chats.py
@@ -1801,6 +1801,8 @@ async def run_tabular_sk_analysis(user_question, tabular_filenames, user_id,
                         'is_workbook': True,
                         'sheet_count': schema_info.get('sheet_count', 0),
                         'likely_sheet': likely_sheet,
+                        'sheet_role_hints': schema_info.get('sheet_role_hints', {}),
+                        'relationship_hints': schema_info.get('relationship_hints', [])[:5],
                         'sheet_directory': sheet_directory,
                     }
                     schema_parts.append(json.dumps(directory_schema, indent=2, default=str))
@@ -2031,8 +2033,8 @@ def build_system_prompt(force_tool_use=False, tool_error_messages=None, executio
                     f"{missing_sheet_feedback}"
                     f"FILE SCHEMAS:\n"
                     f"{schema_context}\n\n"
-                    "AVAILABLE FUNCTIONS: filter_rows, query_tabular_data, lookup_value, aggregate_column, "
-                    "group_by_aggregate, and group_by_datetime_component.\n\n"
+                    "AVAILABLE FUNCTIONS: filter_rows, query_tabular_data, lookup_value, get_distinct_values, count_rows, "
+                    "filter_rows_by_related_values, count_rows_by_related_values, aggregate_column, group_by_aggregate, and group_by_datetime_component.\n\n"
                     "Discovery functions are not available in this analysis run because schema context is already pre-loaded.\n\n"
                     "IMPORTANT:\n"
                     "1. If the question includes an exact identifier or exact entity name and the correct starting worksheet is unclear, begin with filter_rows or query_tabular_data without sheet_name so the plugin can perform a cross-sheet discovery search.\n"
@@ -2046,7 +2048,9 @@ def build_system_prompt(force_tool_use=False, tool_error_messages=None, executio
                     "9. If a requested record type has no corresponding worksheet in the workbook, say that the workbook does not contain that record type.\n"
                     "10. Clearly distinguish between no matching rows and no corresponding worksheet.\n"
                     "11. Summarize concrete found records sheet-by-sheet using the tool results, not schema placeholders.\n"
-                    "12. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report."
+                    "12. For count or percentage questions involving a cohort defined on one sheet and facts on another, prefer get_distinct_values, count_rows, filter_rows_by_related_values, or count_rows_by_related_values over manually counting sampled rows.\n"
+                    "13. Use normalize_match=true when matching names, owners, assignees, engineers, or similar entity-text columns across worksheets.\n"
+                    "14. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report."
                 )
 
             return (
@@ -2065,8 +2069,8 @@ def build_system_prompt(force_tool_use=False, tool_error_messages=None, executio
                 f"{missing_sheet_feedback}"
                 f"FILE SCHEMAS:\n"
                 f"{schema_context}\n\n"
-                "AVAILABLE FUNCTIONS: lookup_value, aggregate_column, filter_rows, query_tabular_data, "
-                "group_by_aggregate, and group_by_datetime_component for year/quarter/month/week/day/hour trend analysis.\n\n"
+                "AVAILABLE FUNCTIONS: lookup_value, get_distinct_values, count_rows, filter_rows, query_tabular_data, "
+                "filter_rows_by_related_values, count_rows_by_related_values, aggregate_column, group_by_aggregate, and group_by_datetime_component for year/quarter/month/week/day/hour trend analysis.\n\n"
                 "Discovery functions are not available in this analysis run because schema context is already pre-loaded.\n\n"
                 "IMPORTANT:\n"
                 "1. Use the pre-loaded schema to pick the correct columns, then call the plugin functions.\n"
@@ -2074,19 +2078,22 @@ def build_system_prompt(force_tool_use=False, tool_error_messages=None, executio
                 "3. If a previous tool error says a requested column is missing on the current sheet and suggests candidate sheets, switch to one of those candidate sheets immediately.\n"
                 "4. For account/category lookup questions at a specific period or metric, use lookup_value first. Provide lookup_column, lookup_value, and target_column.\n"
                 "5. If lookup_value is not sufficient, use filter_rows or query_tabular_data on the label column, then read the requested period column.\n"
-                "6. Only use aggregate_column when the user explicitly asks for a sum, average, min, max, or count across rows.\n"
-                "7. For time-based questions on datetime columns, use group_by_datetime_component.\n"
-                "8. For threshold, ranking, comparison, or correlation-like questions, first filter/query the relevant rows, then compute grouped metrics.\n"
-                "9. When the question asks for grouped results for each entity or category and a cross-sheet bridge plan is available, use the reference worksheet to identify the canonical entities or categories and the fact worksheet to compute the metric. Do not answer 'each X' by grouping a yes/no, boolean, or membership-flag column unless the user explicitly asked about that flag.\n"
-                "10. When the question asks for rows satisfying multiple conditions, prefer one combined query_expression using and/or instead of separate broad queries that you plan to intersect later.\n"
-                "11. Batch multiple independent function calls in a SINGLE response whenever possible.\n"
-                "12. Keep max_rows as small as possible. Only increase it when the user explicitly asked for an exhaustive row list or export; otherwise return total_matches plus representative rows.\n"
-                "13. For analytical questions, prefer lookup/filter/query plus aggregate/grouped computations over raw row or preview output.\n"
-                "14. For identifier-based workbook questions, locate the identifier on the correct sheet before explaining downstream calculations.\n"
-                "15. For peak, busiest, highest, or lowest questions, use grouped functions and inspect the highest_group, highest_value, lowest_group, and lowest_value summary fields.\n"
-                "16. Return only computed findings and name the strongest drivers clearly.\n"
-                "17. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report.\n"
-                "18. When using query_tabular_data, use simple DataFrame.query() syntax with backticked column names for columns containing spaces. Avoid method calls such as .str.lower(), .astype(...), or other Python expressions that DataFrame.query() may reject."
+                "6. For deterministic how-many questions, use count_rows instead of estimating counts from partial returned rows.\n"
+                "7. For cohort, membership, ownership-share, or percentage questions where one sheet defines the group and another sheet contains the fact rows, use get_distinct_values, filter_rows_by_related_values, or count_rows_by_related_values.\n"
+                "8. Use normalize_match=true when matching names, owners, assignees, engineers, or similar entity-text columns across worksheets.\n"
+                "9. Only use aggregate_column when the user explicitly asks for a sum, average, min, max, or count across rows and count_rows is not the simpler deterministic option.\n"
+                "10. For time-based questions on datetime columns, use group_by_datetime_component.\n"
+                "11. For threshold, ranking, comparison, or correlation-like questions, first filter/query the relevant rows, then compute grouped metrics.\n"
+                "12. When the question asks for grouped results for each entity or category and a cross-sheet bridge plan or relationship hint is available, use the reference worksheet to identify the canonical entities or categories and the fact worksheet to compute the metric. Do not answer 'each X' by grouping a yes/no, boolean, or membership-flag column unless the user explicitly asked about that flag.\n"
+                "13. When the question asks for rows satisfying multiple conditions, prefer one combined query_expression using and/or instead of separate broad queries that you plan to intersect later.\n"
+                "14. Batch multiple independent function calls in a SINGLE response whenever possible.\n"
+                "15. Keep max_rows as small as possible. Only increase it when the user explicitly asked for an exhaustive row list or export; otherwise return total_matches plus representative rows.\n"
+                "16. For analytical questions, prefer deterministic counts plus lookup/filter/query/grouped computations over raw row or preview output.\n"
+                "17. For identifier-based workbook questions, locate the identifier on the correct sheet before explaining downstream calculations.\n"
+                "18. For peak, busiest, highest, or lowest questions, use grouped functions and inspect the highest_group, highest_value, lowest_group, and lowest_value summary fields.\n"
+                "19. Return only computed findings and name the strongest drivers clearly.\n"
+                "20. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report.\n"
+                "21. When using query_tabular_data, use simple DataFrame.query() syntax with backticked column names for columns containing spaces. Avoid method calls such as .str.lower(), .astype(...), or other Python expressions that DataFrame.query() may reject."
             )
 
         baseline_invocations = plugin_logger.get_invocations_for_conversation(
diff --git a/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py b/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
index c574cbbb..3dc84a04 100644
--- a/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
+++ b/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
@@ -12,9 +12,10 @@
 import io
 import json
 import logging
+import re
 import warnings
 import pandas
-from typing import Annotated, Optional, List
+from typing import Annotated, Dict, List, Optional, Set
 from semantic_kernel.functions import kernel_function
 from semantic_kernel_plugins.plugin_invocation_logger import plugin_function_logger
 from functions_appinsights import log_event
@@ -38,9 +39,13 @@ class TabularProcessingPlugin:
     )
     ANALYSIS_FUNCTION_NAMES = (
         'lookup_value',
+        'get_distinct_values',
+        'count_rows',
         'aggregate_column',
         'filter_rows',
         'query_tabular_data',
+        'filter_rows_by_related_values',
+        'count_rows_by_related_values',
         'group_by_aggregate',
         'group_by_datetime_component',
     )
@@ -73,6 +78,31 @@ class TabularProcessingPlugin:
         'November',
         'December'
     ]
+    RELATIONSHIP_COLUMN_HINT_TOKENS = {
+        'account',
+        'alias',
+        'assignee',
+        'category',
+        'customer',
+        'email',
+        'employee',
+        'engineer',
+        'group',
+        'id',
+        'manager',
+        'member',
+        'name',
+        'owner',
+        'person',
+        'resource',
+        'se',
+        'solution',
+        'team',
+        'user',
+    }
+    RELATIONSHIP_HINT_LIMIT = 10
+    RELATIONSHIP_VALUE_SAMPLE_LIMIT = 500
+    RELATIONSHIP_SHARED_VALUE_LIMIT = 5
 
     def __init__(self):
         self._df_cache = {}  # Per-instance cache: (container, blob_name, sheet_name) -> DataFrame
@@ -239,6 +269,7 @@ def _filter_rows_across_sheets(
         column: str,
         operator_str: str,
         value: str,
+        normalize_match: bool = False,
         max_rows: int = 100,
     ) -> Optional[str]:
         """Search for matching rows across all sheets that contain the requested column.
@@ -271,40 +302,14 @@ def _filter_rows_across_sheets(
                 continue
 
             sheets_searched.append(sheet)
-            series = df[column]
-            op = operator_str.strip().lower()
-
-            numeric_value = None
             try:
-                numeric_value = float(value)
-            except (ValueError, TypeError):
-                pass
-
-            if op in ('==', 'equals'):
-                if numeric_value is not None and pandas.api.types.is_numeric_dtype(series):
-                    mask = series == numeric_value
-                else:
-                    mask = series.astype(str).str.lower() == value.lower()
-            elif op == '!=':
-                if numeric_value is not None and pandas.api.types.is_numeric_dtype(series):
-                    mask = series != numeric_value
-                else:
-                    mask = series.astype(str).str.lower() != value.lower()
-            elif op == '>':
-                mask = series > numeric_value if numeric_value is not None else pandas.Series([False] * len(series))
-            elif op == '<':
-                mask = series < numeric_value if numeric_value is not None else pandas.Series([False] * len(series))
-            elif op == '>=':
-                mask = series >= numeric_value if numeric_value is not None else pandas.Series([False] * len(series))
-            elif op == '<=':
-                mask = series <= numeric_value if numeric_value is not None else pandas.Series([False] * len(series))
-            elif op == 'contains':
-                mask = series.astype(str).str.contains(value, case=False, na=False)
-            elif op == 'startswith':
-                mask = series.astype(str).str.lower().str.startswith(value.lower())
-            elif op == 'endswith':
-                mask = series.astype(str).str.lower().str.endswith(value.lower())
-            else:
+                mask = self._build_series_match_mask(
+                    df[column],
+                    operator_str,
+                    value,
+                    normalize_match=normalize_match,
+                )
+            except ValueError:
                 continue
 
             sheet_matches = int(mask.sum())
@@ -350,6 +355,7 @@ def _lookup_value_across_sheets(
         lookup_value_str: str,
         target_column: Optional[str] = None,
         match_operator: str = "equals",
+        normalize_match: bool = False,
         max_rows: int = 25,
     ) -> Optional[str]:
         """Look up matching rows across all sheets that contain the lookup column.
@@ -384,18 +390,20 @@ def _lookup_value_across_sheets(
                 continue
 
             sheets_searched.append(sheet)
-            series = df[lookup_column]
-
-            if operator in {'equals', '=='}:
-                mask = series.astype(str).str.lower() == normalized_lookup_value.lower()
-            elif operator == 'contains':
-                mask = series.astype(str).str.contains(normalized_lookup_value, case=False, na=False)
-            elif operator == 'startswith':
-                mask = series.astype(str).str.lower().str.startswith(normalized_lookup_value.lower())
-            elif operator == 'endswith':
-                mask = series.astype(str).str.lower().str.endswith(normalized_lookup_value.lower())
-            else:
-                mask = series.astype(str).str.lower() == normalized_lookup_value.lower()
+            try:
+                mask = self._build_series_match_mask(
+                    df[lookup_column],
+                    operator,
+                    normalized_lookup_value,
+                    normalize_match=normalize_match,
+                )
+            except ValueError:
+                mask = self._build_series_match_mask(
+                    df[lookup_column],
+                    'equals',
+                    normalized_lookup_value,
+                    normalize_match=normalize_match,
+                )
 
             sheet_matches = int(mask.sum())
             if sheet_matches == 0:
@@ -541,6 +549,453 @@ def _query_tabular_data_across_sheets(
             "data": combined_results,
         }, indent=2, default=str)
 
+    def _count_rows_across_sheets(
+        self,
+        container_name: str,
+        blob_name: str,
+        filename: str,
+        filter_column: Optional[str] = None,
+        filter_operator: str = 'equals',
+        filter_value=None,
+        query_expression: Optional[str] = None,
+        normalize_match: bool = False,
+    ) -> Optional[str]:
+        """Count rows across all worksheets that satisfy optional filters or queries."""
+        workbook_metadata = self._get_workbook_metadata(container_name, blob_name)
+        if not workbook_metadata.get('is_workbook'):
+            return None
+
+        available_sheets = workbook_metadata.get('sheet_names', [])
+        if len(available_sheets) <= 1:
+            return None
+
+        sheets_searched = []
+        sheets_matched = []
+        total_count = 0
+        query_errors = []
+        applied_filters = []
+
+        for sheet in available_sheets:
+            df = self._read_tabular_blob_to_dataframe(
+                container_name,
+                blob_name,
+                sheet_name=sheet,
+            )
+            df = self._try_numeric_conversion(df)
+
+            try:
+                filtered_df, sheet_filters = self._apply_optional_dataframe_filters(
+                    df,
+                    query_expression=query_expression,
+                    filter_column=filter_column,
+                    filter_operator=filter_operator,
+                    filter_value=filter_value,
+                    normalize_match=normalize_match,
+                )
+            except KeyError:
+                continue
+            except Exception as query_error:
+                if query_expression:
+                    query_errors.append({
+                        'sheet_name': sheet,
+                        'error': str(query_error),
+                    })
+                continue
+
+            sheets_searched.append(sheet)
+            applied_filters = sheet_filters or applied_filters
+            sheet_count = len(filtered_df)
+            total_count += sheet_count
+            if sheet_count > 0:
+                sheets_matched.append(sheet)
+
+        if not sheets_searched:
+            if query_errors:
+                unique_errors = []
+                seen_errors = set()
+                for query_error in query_errors:
+                    normalized_error = str(query_error.get('error') or '').strip()
+                    if not normalized_error or normalized_error in seen_errors:
+                        continue
+                    seen_errors.add(normalized_error)
+                    unique_errors.append(normalized_error)
+
+                return json.dumps({
+                    'error': (
+                        'Query error: the expression could not be evaluated on any worksheet during cross-sheet row counting. '
+                        'Use simple DataFrame.query() syntax with existing column names, or provide sheet_name to target a specific worksheet.'
+                    ),
+                    'filename': filename,
+                    'selected_sheet': 'ALL (cross-sheet search)',
+                    'query_expression': query_expression,
+                    'details': unique_errors[:3],
+                }, indent=2, default=str)
+            return None
+
+        return json.dumps({
+            'filename': filename,
+            'selected_sheet': 'ALL (cross-sheet search)',
+            'sheets_searched': sheets_searched,
+            'sheets_matched': sheets_matched,
+            'filter_applied': applied_filters,
+            'row_count': total_count,
+            'normalize_match': normalize_match,
+        }, indent=2, default=str)
+
+    def _get_distinct_values_across_sheets(
+        self,
+        container_name: str,
+        blob_name: str,
+        filename: str,
+        column: str,
+        query_expression: Optional[str] = None,
+        filter_column: Optional[str] = None,
+        filter_operator: str = 'equals',
+        filter_value=None,
+        normalize_match: bool = False,
+        max_values: int = 100,
+    ) -> Optional[str]:
+        """Return distinct values for a column across all worksheets that contain it."""
+        workbook_metadata = self._get_workbook_metadata(container_name, blob_name)
+        if not workbook_metadata.get('is_workbook'):
+            return None
+
+        available_sheets = workbook_metadata.get('sheet_names', [])
+        if len(available_sheets) <= 1:
+            return None
+
+        sheets_searched = []
+        sheets_matched = []
+        distinct_display_values = {}
+        query_errors = []
+        applied_filters = []
+
+        for sheet in available_sheets:
+            df = self._read_tabular_blob_to_dataframe(
+                container_name,
+                blob_name,
+                sheet_name=sheet,
+            )
+            if column not in df.columns:
+                continue
+
+            try:
+                filtered_df, sheet_filters = self._apply_optional_dataframe_filters(
+                    df,
+                    query_expression=query_expression,
+                    filter_column=filter_column,
+                    filter_operator=filter_operator,
+                    filter_value=filter_value,
+                    normalize_match=normalize_match,
+                )
+            except KeyError:
+                continue
+            except Exception as query_error:
+                if query_expression:
+                    query_errors.append({
+                        'sheet_name': sheet,
+                        'error': str(query_error),
+                    })
+                continue
+
+            sheets_searched.append(sheet)
+            applied_filters = sheet_filters or applied_filters
+            for cell_value in filtered_df[column].tolist():
+                display_value = str(cell_value).strip()
+                if not display_value:
+                    continue
+                compare_variants = self._extract_cell_value_variants(
+                    cell_value,
+                    normalize_match=normalize_match,
+                )
+                if not compare_variants:
+                    continue
+                canonical_key = sorted(compare_variants)[0]
+                distinct_display_values.setdefault(canonical_key, display_value)
+
+            if not filtered_df.empty:
+                sheets_matched.append(sheet)
+
+        if not sheets_searched:
+            if query_errors:
+                unique_errors = []
+                seen_errors = set()
+                for query_error in query_errors:
+                    normalized_error = str(query_error.get('error') or '').strip()
+                    if not normalized_error or normalized_error in seen_errors:
+                        continue
+                    seen_errors.add(normalized_error)
+                    unique_errors.append(normalized_error)
+
+                return json.dumps({
+                    'error': (
+                        'Query error: the expression could not be evaluated on any worksheet during cross-sheet distinct-value discovery. '
+                        'Use simple DataFrame.query() syntax with existing column names, or provide sheet_name to target a specific worksheet.'
+                    ),
+                    'filename': filename,
+                    'selected_sheet': 'ALL (cross-sheet search)',
+                    'query_expression': query_expression,
+                    'details': unique_errors[:3],
+                }, indent=2, default=str)
+            return None
+
+        ordered_values = sorted(distinct_display_values.values(), key=lambda item: item.casefold())
+        return json.dumps({
+            'filename': filename,
+            'selected_sheet': 'ALL (cross-sheet search)',
+            'column': column,
+            'sheets_searched': sheets_searched,
+            'sheets_matched': sheets_matched,
+            'filter_applied': applied_filters,
+            'normalize_match': normalize_match,
+            'distinct_count': len(ordered_values),
+            'returned_values': min(len(ordered_values), int(max_values)),
+            'values': ordered_values[:int(max_values)],
+            'values_limited': len(ordered_values) > int(max_values),
+        }, indent=2, default=str)
+
+    def _evaluate_related_value_membership(
+        self,
+        container_name: str,
+        blob_name: str,
+        filename: str,
+        source_sheet_name: str,
+        source_value_column: str,
+        target_sheet_name: str,
+        target_match_column: str,
+        source_sheet_index: Optional[str] = None,
+        target_sheet_index: Optional[str] = None,
+        source_query_expression: Optional[str] = None,
+        source_filter_column: Optional[str] = None,
+        source_filter_operator: str = 'equals',
+        source_filter_value=None,
+        target_query_expression: Optional[str] = None,
+        target_filter_column: Optional[str] = None,
+        target_filter_operator: str = 'equals',
+        target_filter_value=None,
+        source_alias_column: Optional[str] = None,
+        target_alias_column: Optional[str] = None,
+        normalize_match: bool = True,
+        max_rows: int = 100,
+    ) -> dict:
+        """Evaluate a semi-join between a source cohort and a target fact worksheet."""
+        source_sheet, workbook_metadata = self._resolve_sheet_selection(
+            container_name,
+            blob_name,
+            sheet_name=source_sheet_name,
+            sheet_index=source_sheet_index,
+            require_explicit_sheet=True,
+        )
+        target_sheet, workbook_metadata = self._resolve_sheet_selection(
+            container_name,
+            blob_name,
+            sheet_name=target_sheet_name,
+            sheet_index=target_sheet_index,
+            require_explicit_sheet=True,
+        )
+
+        source_df = self._read_tabular_blob_to_dataframe(
+            container_name,
+            blob_name,
+            sheet_name=source_sheet,
+            require_explicit_sheet=True,
+        )
+        target_df = self._read_tabular_blob_to_dataframe(
+            container_name,
+            blob_name,
+            sheet_name=target_sheet,
+            require_explicit_sheet=True,
+        )
+
+        source_df = self._try_numeric_conversion(source_df)
+        target_df = self._try_numeric_conversion(target_df)
+
+        source_required_columns = [source_value_column]
+        if source_alias_column:
+            source_required_columns.append(source_alias_column)
+        if source_filter_column:
+            source_required_columns.append(source_filter_column)
+
+        target_required_columns = [target_match_column]
+        if target_alias_column:
+            target_required_columns.append(target_alias_column)
+        if target_filter_column:
+            target_required_columns.append(target_filter_column)
+
+        for required_column in source_required_columns:
+            if required_column not in source_df.columns:
+                return self._build_missing_column_error_payload(
+                    container_name,
+                    blob_name,
+                    filename,
+                    workbook_metadata,
+                    source_sheet,
+                    required_column,
+                    related_columns=[source_value_column, source_alias_column, source_filter_column],
+                    available_columns=list(source_df.columns),
+                )
+
+        for required_column in target_required_columns:
+            if required_column not in target_df.columns:
+                return self._build_missing_column_error_payload(
+                    container_name,
+                    blob_name,
+                    filename,
+                    workbook_metadata,
+                    target_sheet,
+                    required_column,
+                    related_columns=[target_match_column, target_alias_column, target_filter_column],
+                    available_columns=list(target_df.columns),
+                )
+
+        try:
+            filtered_source_df, source_filters = self._apply_optional_dataframe_filters(
+                source_df,
+                query_expression=source_query_expression,
+                filter_column=source_filter_column,
+                filter_operator=source_filter_operator,
+                filter_value=source_filter_value,
+                normalize_match=normalize_match,
+            )
+        except KeyError as missing_source_column_error:
+            missing_source_column = str(missing_source_column_error).strip("'")
+            return self._build_missing_column_error_payload(
+                container_name,
+                blob_name,
+                filename,
+                workbook_metadata,
+                source_sheet,
+                missing_source_column,
+                related_columns=[source_value_column, source_alias_column],
+                available_columns=list(source_df.columns),
+            )
+        except Exception as source_filter_error:
+            return {
+                'error': f"Source filter/query error on sheet '{source_sheet}': {source_filter_error}",
+                'filename': filename,
+                'selected_sheet': source_sheet if workbook_metadata.get('is_workbook') else None,
+            }
+
+        try:
+            filtered_target_df, target_filters = self._apply_optional_dataframe_filters(
+                target_df,
+                query_expression=target_query_expression,
+                filter_column=target_filter_column,
+                filter_operator=target_filter_operator,
+                filter_value=target_filter_value,
+                normalize_match=normalize_match,
+            )
+        except KeyError as missing_target_column_error:
+            missing_target_column = str(missing_target_column_error).strip("'")
+            return self._build_missing_column_error_payload(
+                container_name,
+                blob_name,
+                filename,
+                workbook_metadata,
+                target_sheet,
+                missing_target_column,
+                related_columns=[target_match_column, target_alias_column],
+                available_columns=list(target_df.columns),
+            )
+        except Exception as target_filter_error:
+            return {
+                'error': f"Target filter/query error on sheet '{target_sheet}': {target_filter_error}",
+                'filename': filename,
+                'selected_sheet': target_sheet if workbook_metadata.get('is_workbook') else None,
+            }
+
+        source_member_map = {}
+        for _, source_row in filtered_source_df.iterrows():
+            display_value = str(source_row.get(source_value_column, '')).strip()
+            value_variants = set()
+            for column_name in [source_value_column, source_alias_column]:
+                if not column_name:
+                    continue
+                value_variants.update(
+                    self._extract_cell_value_variants(
+                        source_row.get(column_name),
+                        normalize_match=normalize_match,
+                    )
+                )
+
+            if not value_variants:
+                continue
+
+            primary_variants = self._extract_cell_value_variants(
+                source_row.get(source_value_column),
+                normalize_match=normalize_match,
+            )
+            primary_key = sorted(primary_variants or value_variants)[0]
+            existing_member = source_member_map.setdefault(
+                primary_key,
+                {
+                    'display_value': display_value or primary_key,
+                    'value_variants': set(),
+                },
+            )
+            existing_member['value_variants'].update(value_variants)
+
+        source_compare_values = set()
+        for source_member in source_member_map.values():
+            source_compare_values.update(source_member['value_variants'])
+
+        matched_target_rows = []
+        matched_target_value_variants = set()
+        for _, target_row in filtered_target_df.iterrows():
+            target_value_variants = set()
+            for column_name in [target_match_column, target_alias_column]:
+                if not column_name:
+                    continue
+                target_value_variants.update(
+                    self._extract_cell_value_variants(
+                        target_row.get(column_name),
+                        normalize_match=normalize_match,
+                    )
+                )
+
+            matched_variants = sorted(target_value_variants & source_compare_values)
+            if not matched_variants:
+                continue
+
+            matched_target_value_variants.update(matched_variants)
+            matched_row_payload = target_row.to_dict()
+            matched_row_payload['_matched_on'] = matched_variants[:3]
+            matched_target_rows.append(matched_row_payload)
+
+        matched_source_values = []
+        unmatched_source_values = []
+        for source_member in source_member_map.values():
+            if source_member['value_variants'] & matched_target_value_variants:
+                matched_source_values.append(source_member['display_value'])
+            else:
+                unmatched_source_values.append(source_member['display_value'])
+
+        matched_target_row_count = len(matched_target_rows)
+        return {
+            'filename': filename,
+            'selected_sheet': target_sheet if workbook_metadata.get('is_workbook') else None,
+            'relationship_type': 'set_membership',
+            'source_sheet': source_sheet,
+            'source_value_column': source_value_column,
+            'source_alias_column': source_alias_column,
+            'target_sheet': target_sheet,
+            'target_match_column': target_match_column,
+            'target_alias_column': target_alias_column,
+            'normalize_match': normalize_match,
+            'source_filter_applied': source_filters,
+            'target_filter_applied': target_filters,
+            'source_cohort_size': len(source_member_map),
+            'matched_source_value_count': len(matched_source_values),
+            'matched_source_values_sample': matched_source_values[:10],
+            'unmatched_source_value_count': len(unmatched_source_values),
+            'unmatched_source_values_sample': unmatched_source_values[:10],
+            'target_rows_scanned': len(filtered_target_df),
+            'matched_target_row_count': matched_target_row_count,
+            'returned_rows': min(matched_target_row_count, max_rows),
+            'rows_limited': matched_target_row_count > max_rows,
+            'data': matched_target_rows[:max_rows],
+        }
+
     def _format_datetime_column_label(self, value) -> str:
         """Render date-like Excel header labels into stable analysis-friendly strings."""
         timestamp_value = pandas.Timestamp(value)
@@ -593,6 +1048,394 @@ def _normalize_dataframe_columns(self, df: pandas.DataFrame) -> pandas.DataFrame
         normalized_df.columns = normalized_columns
         return normalized_df
 
+    def _normalize_entity_match_text(self, value) -> Optional[str]:
+        """Normalize entity-style text for stable name and owner comparisons."""
+        if value is None or (not isinstance(value, str) and pandas.isna(value)):
+            return None
+
+        normalized = str(value).casefold().replace('&', ' and ')
+        normalized = re.sub(r"[`'\u2018\u2019\u201b]+", '', normalized)
+        normalized = re.sub(r'[^0-9a-z]+', ' ', normalized)
+        normalized = ' '.join(normalized.split())
+        return normalized or None
+
+    def _extract_cell_value_variants(self, value, normalize_match: bool = False) -> Set[str]:
+        """Return one or more comparable value variants from a cell, including aliases."""
+        if value is None or (not isinstance(value, str) and pandas.isna(value)):
+            return set()
+
+        raw_text = str(value).strip()
+        if not raw_text:
+            return set()
+
+        parts = [raw_text]
+        if ';' in raw_text or '|' in raw_text:
+            split_parts = re.split(r'[;|]+', raw_text)
+            parts = [part.strip() for part in split_parts if part.strip()]
+
+        variants = set()
+        for part in parts:
+            if normalize_match:
+                normalized_part = self._normalize_entity_match_text(part)
+            else:
+                normalized_part = part.casefold().strip()
+            if normalized_part:
+                variants.add(normalized_part)
+
+        return variants
+
+    def _build_series_match_mask(
+        self,
+        series: pandas.Series,
+        operator: str,
+        value,
+        normalize_match: bool = False,
+    ) -> pandas.Series:
+        """Build a boolean mask for a comparison against a DataFrame column."""
+        op = (operator or 'equals').strip().lower()
+
+        numeric_value = None
+        try:
+            numeric_value = float(value)
+        except (ValueError, TypeError):
+            numeric_value = None
+
+        if op in {'==', 'equals'}:
+            if numeric_value is not None and pandas.api.types.is_numeric_dtype(series):
+                return series == numeric_value
+            if normalize_match:
+                normalized_value = self._normalize_entity_match_text(value)
+                normalized_series = series.map(self._normalize_entity_match_text)
+                return normalized_series == normalized_value
+            return series.astype(str).str.lower() == str(value).lower()
+
+        if op == '!=':
+            if numeric_value is not None and pandas.api.types.is_numeric_dtype(series):
+                return series != numeric_value
+            if normalize_match:
+                normalized_value = self._normalize_entity_match_text(value)
+                normalized_series = series.map(self._normalize_entity_match_text)
+                return normalized_series != normalized_value
+            return series.astype(str).str.lower() != str(value).lower()
+
+        if op == '>':
+            if numeric_value is None:
+                return pandas.Series([False] * len(series), index=series.index)
+            return series > numeric_value
+
+        if op == '<':
+            if numeric_value is None:
+                return pandas.Series([False] * len(series), index=series.index)
+            return series < numeric_value
+
+        if op == '>=':
+            if numeric_value is None:
+                return pandas.Series([False] * len(series), index=series.index)
+            return series >= numeric_value
+
+        if op == '<=':
+            if numeric_value is None:
+                return pandas.Series([False] * len(series), index=series.index)
+            return series <= numeric_value
+
+        if normalize_match:
+            normalized_value = self._normalize_entity_match_text(value)
+            normalized_series = series.map(self._normalize_entity_match_text).fillna('')
+            if not normalized_value:
+                return pandas.Series([False] * len(series), index=series.index)
+
+            if op == 'contains':
+                return normalized_series.str.contains(normalized_value, regex=False, na=False)
+            if op == 'startswith':
+                return normalized_series.str.startswith(normalized_value, na=False)
+            if op == 'endswith':
+                return normalized_series.str.endswith(normalized_value, na=False)
+        else:
+            text_series = series.astype(str)
+            value_text = str(value)
+            if op == 'contains':
+                return text_series.str.contains(value_text, case=False, na=False)
+            if op == 'startswith':
+                return text_series.str.lower().str.startswith(value_text.lower())
+            if op == 'endswith':
+                return text_series.str.lower().str.endswith(value_text.lower())
+
+        raise ValueError(f"Unsupported operator: {operator}")
+
+    def _apply_optional_dataframe_filters(
+        self,
+        df: pandas.DataFrame,
+        query_expression: Optional[str] = None,
+        filter_column: Optional[str] = None,
+        filter_operator: str = 'equals',
+        filter_value=None,
+        normalize_match: bool = False,
+    ) -> tuple:
+        """Apply optional query and single-column filters to a DataFrame."""
+        filtered_df = df
+        applied_filters = []
+
+        if query_expression:
+            filtered_df = filtered_df.query(query_expression)
+            applied_filters.append(f"query_expression={query_expression}")
+
+        if filter_column:
+            if filter_column not in filtered_df.columns:
+                raise KeyError(filter_column)
+            if filter_value is None:
+                raise ValueError('filter_value is required when filter_column is provided.')
+
+            mask = self._build_series_match_mask(
+                filtered_df[filter_column],
+                filter_operator,
+                filter_value,
+                normalize_match=normalize_match,
+            )
+            filtered_df = filtered_df[mask]
+            applied_filters.append(
+                f"{filter_column} {filter_operator or 'equals'} {filter_value}"
+                + (' [normalized]' if normalize_match else '')
+            )
+
+        return filtered_df, applied_filters
+
+    def _column_name_tokens(self, column_name: str) -> List[str]:
+        """Tokenize a column label for relationship heuristics."""
+        normalized = re.sub(r'[^0-9a-z]+', ' ', str(column_name or '').casefold())
+        return [token for token in normalized.split() if token]
+
+    def _build_relationship_column_profile(self, column_name: str, series: pandas.Series) -> dict:
+        """Build a compact column profile used for workbook relationship inference."""
+        tokens = self._column_name_tokens(column_name)
+        non_null_series = series.dropna()
+        name_hint_score = sum(1 for token in tokens if token in self.RELATIONSHIP_COLUMN_HINT_TOKENS)
+        is_identifier_like = any(token == 'id' or token.endswith('id') for token in tokens)
+        is_entity_like = name_hint_score > 0 or is_identifier_like
+        distinct_count = int(non_null_series.astype(str).nunique(dropna=True)) if not non_null_series.empty else 0
+
+        normalized_values = []
+        seen_values = set()
+        for raw_value in non_null_series.astype(str):
+            normalized_value = self._normalize_entity_match_text(raw_value)
+            if not normalized_value or normalized_value in seen_values:
+                continue
+            seen_values.add(normalized_value)
+            normalized_values.append(normalized_value)
+            if len(normalized_values) >= self.RELATIONSHIP_VALUE_SAMPLE_LIMIT:
+                break
+
+        return {
+            'column_name': column_name,
+            'normalized_column_name': ' '.join(tokens),
+            'tokens': tokens,
+            'name_hint_score': name_hint_score,
+            'is_identifier_like': is_identifier_like,
+            'is_entity_like': is_entity_like,
+            'distinct_count': distinct_count,
+            'normalized_value_set': set(normalized_values),
+            'sample_distinct_count': len(normalized_values),
+            'is_numeric': pandas.api.types.is_numeric_dtype(series),
+        }
+
+    def _infer_sheet_role_hint(self, sheet_name: str, row_count: int, column_profiles: List[dict], max_row_count: int) -> dict:
+        """Infer whether a worksheet looks like a fact, dimension, or metadata table."""
+        normalized_sheet_name = str(sheet_name or '').casefold()
+        entity_profiles = [profile for profile in column_profiles if profile['is_entity_like']]
+        natural_key_profiles = [
+            profile for profile in entity_profiles
+            if profile['distinct_count'] >= max(2, row_count - 1)
+        ]
+        repeated_entity_profiles = [
+            profile for profile in entity_profiles
+            if 0 < profile['distinct_count'] < row_count
+        ]
+        join_columns = [
+            profile['column_name']
+            for profile in sorted(
+                column_profiles,
+                key=lambda item: (-item['name_hint_score'], item['distinct_count'], item['column_name'].casefold())
+            )
+            if profile['is_entity_like']
+        ][:5]
+
+        if any(token in normalized_sheet_name for token in ('meta', 'config', 'summary', 'readme', 'about')):
+            return {
+                'role': 'metadata',
+                'reason': 'sheet name suggests metadata or workbook configuration',
+                'row_count': row_count,
+                'likely_join_columns': join_columns,
+            }
+
+        if row_count >= max(25, max_row_count // 2 or 1) and repeated_entity_profiles:
+            return {
+                'role': 'fact',
+                'reason': 'larger table contains repeated entity values consistent with transactional rows',
+                'row_count': row_count,
+                'likely_join_columns': join_columns,
+            }
+
+        if natural_key_profiles and row_count <= max(200, max_row_count // 4 or 1):
+            return {
+                'role': 'dimension',
+                'reason': 'smaller table contains near-unique entity keys suitable for cohort or lookup joins',
+                'row_count': row_count,
+                'likely_join_columns': join_columns,
+            }
+
+        if row_count <= 5 and not entity_profiles and len(column_profiles) <= 6:
+            return {
+                'role': 'metadata',
+                'reason': 'very small table with limited columns',
+                'row_count': row_count,
+                'likely_join_columns': join_columns,
+            }
+
+        if join_columns and row_count <= max(200, max_row_count // 4 or 1):
+            return {
+                'role': 'dimension',
+                'reason': 'smaller table with entity-like or identifier-like columns',
+                'row_count': row_count,
+                'likely_join_columns': join_columns,
+            }
+
+        if row_count >= max(25, max_row_count // 2 or 1):
+            return {
+                'role': 'fact',
+                'reason': 'larger table likely containing repeated transactional or milestone-style rows',
+                'row_count': row_count,
+                'likely_join_columns': join_columns,
+            }
+
+        return {
+            'role': 'unknown',
+            'reason': 'insufficient evidence to confidently classify worksheet role',
+            'row_count': row_count,
+            'likely_join_columns': join_columns,
+        }
+
+    def _build_workbook_relationship_metadata(self, sheet_dataframes: Dict[str, pandas.DataFrame]) -> dict:
+        """Infer likely worksheet roles and relationship hints from workbook data."""
+        if len(sheet_dataframes) <= 1:
+            return {
+                'sheet_role_hints': {},
+                'relationship_hints': [],
+            }
+
+        max_row_count = max((len(dataframe) for dataframe in sheet_dataframes.values()), default=0)
+        column_profiles_by_sheet = {}
+        sheet_role_hints = {}
+
+        for sheet_name, dataframe in sheet_dataframes.items():
+            column_profiles = [
+                self._build_relationship_column_profile(column_name, dataframe[column_name])
+                for column_name in dataframe.columns
+            ]
+            candidate_profiles = [
+                profile for profile in column_profiles
+                if profile['is_entity_like']
+                or profile['distinct_count'] <= max(50, len(dataframe))
+            ]
+            column_profiles_by_sheet[sheet_name] = candidate_profiles[:8]
+            sheet_role_hints[sheet_name] = self._infer_sheet_role_hint(
+                sheet_name,
+                len(dataframe),
+                candidate_profiles,
+                max_row_count,
+            )
+
+        relationship_hints = []
+        sheet_names = list(sheet_dataframes.keys())
+        for left_index, left_sheet in enumerate(sheet_names):
+            for right_sheet in sheet_names[left_index + 1:]:
+                left_profiles = column_profiles_by_sheet.get(left_sheet, [])
+                right_profiles = column_profiles_by_sheet.get(right_sheet, [])
+                left_role_hint = sheet_role_hints.get(left_sheet, {})
+                right_role_hint = sheet_role_hints.get(right_sheet, {})
+
+                for left_profile in left_profiles:
+                    for right_profile in right_profiles:
+                        overlap_values = sorted(
+                            left_profile['normalized_value_set'] & right_profile['normalized_value_set']
+                        )
+                        overlap_count = len(overlap_values)
+                        token_overlap_count = len(
+                            set(left_profile['tokens']) & set(right_profile['tokens'])
+                        )
+                        exact_column_name_match = (
+                            left_profile['normalized_column_name']
+                            and left_profile['normalized_column_name'] == right_profile['normalized_column_name']
+                        )
+
+                        if overlap_count == 0:
+                            continue
+                        if overlap_count < 2 and not exact_column_name_match and token_overlap_count == 0:
+                            continue
+
+                        left_distinct = max(1, left_profile['sample_distinct_count'])
+                        right_distinct = max(1, right_profile['sample_distinct_count'])
+                        overlap_ratio_vs_smaller = round(overlap_count / min(left_distinct, right_distinct), 3)
+
+                        if left_role_hint.get('role') == 'dimension' and right_role_hint.get('role') == 'fact':
+                            reference_sheet = left_sheet
+                            reference_profile = left_profile
+                            reference_role = left_role_hint.get('role')
+                            fact_sheet = right_sheet
+                            fact_profile = right_profile
+                            fact_role = right_role_hint.get('role')
+                        elif right_role_hint.get('role') == 'dimension' and left_role_hint.get('role') == 'fact':
+                            reference_sheet = right_sheet
+                            reference_profile = right_profile
+                            reference_role = right_role_hint.get('role')
+                            fact_sheet = left_sheet
+                            fact_profile = left_profile
+                            fact_role = left_role_hint.get('role')
+                        elif len(sheet_dataframes[left_sheet]) <= len(sheet_dataframes[right_sheet]):
+                            reference_sheet = left_sheet
+                            reference_profile = left_profile
+                            reference_role = left_role_hint.get('role')
+                            fact_sheet = right_sheet
+                            fact_profile = right_profile
+                            fact_role = right_role_hint.get('role')
+                        else:
+                            reference_sheet = right_sheet
+                            reference_profile = right_profile
+                            reference_role = right_role_hint.get('role')
+                            fact_sheet = left_sheet
+                            fact_profile = left_profile
+                            fact_role = left_role_hint.get('role')
+
+                        relationship_hints.append({
+                            'reference_sheet': reference_sheet,
+                            'reference_column': reference_profile['column_name'],
+                            'reference_role': reference_role,
+                            'fact_sheet': fact_sheet,
+                            'fact_column': fact_profile['column_name'],
+                            'fact_role': fact_role,
+                            'normalized_overlap_count': overlap_count,
+                            'reference_distinct_count': reference_profile['sample_distinct_count'],
+                            'fact_distinct_count': fact_profile['sample_distinct_count'],
+                            'overlap_ratio_vs_smaller_set': overlap_ratio_vs_smaller,
+                            'exact_column_name_match': bool(exact_column_name_match),
+                            'shared_name_token_count': token_overlap_count,
+                            'sample_overlap_values': overlap_values[:self.RELATIONSHIP_SHARED_VALUE_LIMIT],
+                        })
+
+        relationship_hints.sort(
+            key=lambda item: (
+                -item['normalized_overlap_count'],
+                -item['overlap_ratio_vs_smaller_set'],
+                -int(item['exact_column_name_match']),
+                -item['shared_name_token_count'],
+                item['reference_sheet'].casefold(),
+                item['fact_sheet'].casefold(),
+            )
+        )
+
+        return {
+            'sheet_role_hints': sheet_role_hints,
+            'relationship_hints': relationship_hints[:self.RELATIONSHIP_HINT_LIMIT],
+        }
+
     def _build_sheet_schema_summary(self, df: pandas.DataFrame, sheet_name: Optional[str], preview_rows: int = 3) -> dict:
         """Build a compact schema summary for a single table or worksheet."""
         df = self._normalize_dataframe_columns(df)
@@ -622,18 +1465,22 @@ def _build_workbook_schema_summary(self, container_name: str, blob_name: str, fi
             return summary
 
         per_sheet_schemas = {}
+        sheet_dataframes = {}
         for workbook_sheet_name in workbook_metadata.get('sheet_names', []):
             df = self._read_tabular_blob_to_dataframe(
                 container_name,
                 blob_name,
                 sheet_name=workbook_sheet_name,
             )
+            sheet_dataframes[workbook_sheet_name] = df.copy()
             per_sheet_schemas[workbook_sheet_name] = self._build_sheet_schema_summary(
                 df,
                 workbook_sheet_name,
                 preview_rows=preview_rows,
             )
 
+        relationship_metadata = self._build_workbook_relationship_metadata(sheet_dataframes)
+
         return {
             'filename': filename,
             'is_workbook': True,
@@ -641,6 +1488,8 @@ def _build_workbook_schema_summary(self, container_name: str, blob_name: str, fi
             'sheet_count': workbook_metadata.get('sheet_count', 0),
             'selected_sheet': None,
             'per_sheet_schemas': per_sheet_schemas,
+            'sheet_role_hints': relationship_metadata.get('sheet_role_hints', {}),
+            'relationship_hints': relationship_metadata.get('relationship_hints', []),
         }
 
     def _find_candidate_sheets_for_columns(
@@ -1260,6 +2109,7 @@ async def lookup_value(
         lookup_value: Annotated[str, "The row label/category value to search for, such as Total Assets"],
         target_column: Annotated[str, "The target column containing the desired value, such as Nov-25"],
         match_operator: Annotated[str, "Match operator: equals, contains, startswith, endswith"] = "equals",
+        normalize_match: Annotated[str, "Whether to normalize string/entity matching for text comparisons (true/false)"] = "false",
         sheet_name: Annotated[Optional[str], "Optional worksheet name for Excel files. Required for analytical calls on multi-sheet workbooks unless sheet_index is provided."] = None,
         sheet_index: Annotated[Optional[str], "Optional zero-based worksheet index for Excel files. Ignored when sheet_name is provided."] = None,
         source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat",
@@ -1270,6 +2120,7 @@ async def lookup_value(
         """Look up values from a target column for matching rows."""
         def _sync_work():
             try:
+                normalize_match_flag = self._parse_boolean_argument(normalize_match, default=False)
                 container, blob_path = self._resolve_blob_location_with_fallback(
                     user_id, conversation_id, filename, source,
                     group_id=group_id, public_workspace_id=public_workspace_id
@@ -1282,6 +2133,7 @@ def _sync_work():
                         container, blob_path, filename,
                         lookup_column, lookup_value, target_column,
                         match_operator=match_operator,
+                        normalize_match=normalize_match_flag,
                         max_rows=int(max_rows),
                     )
                     if cross_sheet_result is not None:
@@ -1328,19 +2180,17 @@ def _sync_work():
                         )
                     )
 
-                series = df[lookup_column]
                 operator = (match_operator or 'equals').strip().lower()
                 normalized_lookup_value = str(lookup_value)
 
-                if operator in {'equals', '=='}:
-                    mask = series.astype(str).str.lower() == normalized_lookup_value.lower()
-                elif operator == 'contains':
-                    mask = series.astype(str).str.contains(normalized_lookup_value, case=False, na=False)
-                elif operator == 'startswith':
-                    mask = series.astype(str).str.lower().str.startswith(normalized_lookup_value.lower())
-                elif operator == 'endswith':
-                    mask = series.astype(str).str.lower().str.endswith(normalized_lookup_value.lower())
-                else:
+                try:
+                    mask = self._build_series_match_mask(
+                        df[lookup_column],
+                        operator,
+                        normalized_lookup_value,
+                        normalize_match=normalize_match_flag,
+                    )
+                except ValueError:
                     return json.dumps({"error": f"Unsupported match_operator: {match_operator}"})
 
                 limit = int(max_rows)
@@ -1352,6 +2202,7 @@ def _sync_work():
                     "lookup_value": lookup_value,
                     "target_column": target_column,
                     "match_operator": operator,
+                    "normalize_match": normalize_match_flag,
                     "total_matches": int(mask.sum()),
                     "returned_rows": len(matches),
                     "data": matches.to_dict(orient='records'),
@@ -1366,6 +2217,257 @@ def _sync_work():
                 return json.dumps({"error": str(e)})
         return await asyncio.to_thread(_sync_work)
 
+    @kernel_function(
+        description=(
+            "Return deterministic distinct values for a column, with optional query_expression or filter criteria. "
+            "Use this to build a canonical cohort from a worksheet before counting or joining related rows."
+        ),
+        name="get_distinct_values"
+    )
+    @plugin_function_logger("TabularProcessingPlugin")
+    async def get_distinct_values(
+        self,
+        user_id: Annotated[str, "The user ID (from Scope ID in Conversation Metadata)"],
+        conversation_id: Annotated[str, "The conversation ID (from Conversation Metadata)"],
+        filename: Annotated[str, "The filename of the tabular file"],
+        column: Annotated[str, "The column from which to return distinct values"],
+        query_expression: Annotated[Optional[str], "Optional pandas DataFrame.query() expression to apply before collecting distinct values"] = None,
+        filter_column: Annotated[Optional[str], "Optional column to filter on before collecting distinct values"] = None,
+        filter_operator: Annotated[str, "Optional filter operator when filter_column is provided"] = "equals",
+        filter_value: Annotated[Optional[str], "Optional filter value when filter_column is provided"] = None,
+        normalize_match: Annotated[str, "Whether to normalize string/entity matching and deduplication (true/false)"] = "true",
+        sheet_name: Annotated[Optional[str], "Optional worksheet name for Excel files. When omitted, the plugin may perform a cross-sheet distinct-value search."] = None,
+        sheet_index: Annotated[Optional[str], "Optional zero-based worksheet index for Excel files. Ignored when sheet_name is provided."] = None,
+        source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat",
+        max_values: Annotated[str, "Maximum distinct values to return"] = "100",
+        group_id: Annotated[Optional[str], "Group ID (for group workspace documents)"] = None,
+        public_workspace_id: Annotated[Optional[str], "Public workspace ID (for public workspace documents)"] = None,
+    ) -> Annotated[str, "JSON result containing deterministic distinct values and counts"]:
+        """Return deterministic distinct values from a worksheet or across worksheets."""
+        def _sync_work():
+            try:
+                normalize_match_flag = self._parse_boolean_argument(normalize_match, default=True)
+                container, blob_path = self._resolve_blob_location_with_fallback(
+                    user_id, conversation_id, filename, source,
+                    group_id=group_id, public_workspace_id=public_workspace_id
+                )
+
+                normalized_sheet = (sheet_name or '').strip()
+                normalized_sheet_idx = None if sheet_index is None else str(sheet_index).strip()
+                if not normalized_sheet and normalized_sheet_idx in (None, ''):
+                    cross_sheet_result = self._get_distinct_values_across_sheets(
+                        container,
+                        blob_path,
+                        filename,
+                        column,
+                        query_expression=query_expression,
+                        filter_column=filter_column,
+                        filter_operator=filter_operator,
+                        filter_value=filter_value,
+                        normalize_match=normalize_match_flag,
+                        max_values=int(max_values),
+                    )
+                    if cross_sheet_result is not None:
+                        return cross_sheet_result
+
+                selected_sheet, workbook_metadata = self._resolve_sheet_selection(
+                    container,
+                    blob_path,
+                    sheet_name=sheet_name,
+                    sheet_index=sheet_index,
+                    require_explicit_sheet=True,
+                )
+                df = self._read_tabular_blob_to_dataframe(
+                    container,
+                    blob_path,
+                    sheet_name=selected_sheet,
+                    require_explicit_sheet=True,
+                )
+
+                if column not in df.columns:
+                    return json.dumps(
+                        self._build_missing_column_error_payload(
+                            container,
+                            blob_path,
+                            filename,
+                            workbook_metadata,
+                            selected_sheet,
+                            column,
+                            related_columns=[filter_column] if filter_column else None,
+                            available_columns=list(df.columns),
+                        )
+                    )
+
+                try:
+                    filtered_df, applied_filters = self._apply_optional_dataframe_filters(
+                        df,
+                        query_expression=query_expression,
+                        filter_column=filter_column,
+                        filter_operator=filter_operator,
+                        filter_value=filter_value,
+                        normalize_match=normalize_match_flag,
+                    )
+                except KeyError as missing_column_error:
+                    missing_column = str(missing_column_error).strip("'")
+                    return json.dumps(
+                        self._build_missing_column_error_payload(
+                            container,
+                            blob_path,
+                            filename,
+                            workbook_metadata,
+                            selected_sheet,
+                            missing_column,
+                            related_columns=[column],
+                            available_columns=list(df.columns),
+                        )
+                    )
+                except Exception as query_error:
+                    return json.dumps({
+                        'error': f"Query/filter error: {query_error}",
+                        'filename': filename,
+                        'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None,
+                    })
+
+                distinct_display_values = {}
+                for cell_value in filtered_df[column].tolist():
+                    display_value = str(cell_value).strip()
+                    if not display_value:
+                        continue
+                    compare_variants = self._extract_cell_value_variants(
+                        cell_value,
+                        normalize_match=normalize_match_flag,
+                    )
+                    if not compare_variants:
+                        continue
+                    canonical_key = sorted(compare_variants)[0]
+                    distinct_display_values.setdefault(canonical_key, display_value)
+
+                ordered_values = sorted(distinct_display_values.values(), key=lambda item: item.casefold())
+                limit = int(max_values)
+                return json.dumps({
+                    'filename': filename,
+                    'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None,
+                    'column': column,
+                    'filter_applied': applied_filters,
+                    'normalize_match': normalize_match_flag,
+                    'distinct_count': len(ordered_values),
+                    'returned_values': min(len(ordered_values), limit),
+                    'values': ordered_values[:limit],
+                    'values_limited': len(ordered_values) > limit,
+                }, indent=2, default=str)
+            except Exception as e:
+                log_event(f"[TabularProcessingPlugin] Error getting distinct values: {e}", level=logging.WARNING)
+                return json.dumps({"error": str(e)})
+
+        return await asyncio.to_thread(_sync_work)
+
+    @kernel_function(
+        description=(
+            "Return a deterministic row count after applying an optional query_expression or filter condition. "
+            "Use this instead of estimating counts from partial returned rows when the user asks how many or what percentage."
+        ),
+        name="count_rows"
+    )
+    @plugin_function_logger("TabularProcessingPlugin")
+    async def count_rows(
+        self,
+        user_id: Annotated[str, "The user ID (from Scope ID in Conversation Metadata)"],
+        conversation_id: Annotated[str, "The conversation ID (from Conversation Metadata)"],
+        filename: Annotated[str, "The filename of the tabular file"],
+        query_expression: Annotated[Optional[str], "Optional pandas DataFrame.query() expression to apply before counting rows"] = None,
+        filter_column: Annotated[Optional[str], "Optional column to filter on before counting rows"] = None,
+        filter_operator: Annotated[str, "Optional filter operator when filter_column is provided"] = "equals",
+        filter_value: Annotated[Optional[str], "Optional filter value when filter_column is provided"] = None,
+        normalize_match: Annotated[str, "Whether to normalize string/entity matching for text comparisons (true/false)"] = "false",
+        sheet_name: Annotated[Optional[str], "Optional worksheet name for Excel files. When omitted, the plugin may perform a cross-sheet row count."] = None,
+        sheet_index: Annotated[Optional[str], "Optional zero-based worksheet index for Excel files. Ignored when sheet_name is provided."] = None,
+        source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat",
+        group_id: Annotated[Optional[str], "Group ID (for group workspace documents)"] = None,
+        public_workspace_id: Annotated[Optional[str], "Public workspace ID (for public workspace documents)"] = None,
+    ) -> Annotated[str, "JSON result containing a deterministic row count"]:
+        """Count rows deterministically after optional filters or queries."""
+        def _sync_work():
+            try:
+                normalize_match_flag = self._parse_boolean_argument(normalize_match, default=False)
+                container, blob_path = self._resolve_blob_location_with_fallback(
+                    user_id, conversation_id, filename, source,
+                    group_id=group_id, public_workspace_id=public_workspace_id
+                )
+
+                normalized_sheet = (sheet_name or '').strip()
+                normalized_sheet_idx = None if sheet_index is None else str(sheet_index).strip()
+                if not normalized_sheet and normalized_sheet_idx in (None, ''):
+                    cross_sheet_result = self._count_rows_across_sheets(
+                        container,
+                        blob_path,
+                        filename,
+                        filter_column=filter_column,
+                        filter_operator=filter_operator,
+                        filter_value=filter_value,
+                        query_expression=query_expression,
+                        normalize_match=normalize_match_flag,
+                    )
+                    if cross_sheet_result is not None:
+                        return cross_sheet_result
+
+                selected_sheet, workbook_metadata = self._resolve_sheet_selection(
+                    container,
+                    blob_path,
+                    sheet_name=sheet_name,
+                    sheet_index=sheet_index,
+                    require_explicit_sheet=True,
+                )
+                df = self._read_tabular_blob_to_dataframe(
+                    container,
+                    blob_path,
+                    sheet_name=selected_sheet,
+                    require_explicit_sheet=True,
+                )
+                df = self._try_numeric_conversion(df)
+
+                try:
+                    filtered_df, applied_filters = self._apply_optional_dataframe_filters(
+                        df,
+                        query_expression=query_expression,
+                        filter_column=filter_column,
+                        filter_operator=filter_operator,
+                        filter_value=filter_value,
+                        normalize_match=normalize_match_flag,
+                    )
+                except KeyError as missing_column_error:
+                    missing_column = str(missing_column_error).strip("'")
+                    return json.dumps(
+                        self._build_missing_column_error_payload(
+                            container,
+                            blob_path,
+                            filename,
+                            workbook_metadata,
+                            selected_sheet,
+                            missing_column,
+                            available_columns=list(df.columns),
+                        )
+                    )
+                except Exception as query_error:
+                    return json.dumps({
+                        'error': f"Query/filter error: {query_error}",
+                        'filename': filename,
+                        'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None,
+                    })
+
+                return json.dumps({
+                    'filename': filename,
+                    'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None,
+                    'rows_scanned': len(df),
+                    'row_count': len(filtered_df),
+                    'filter_applied': applied_filters,
+                    'normalize_match': normalize_match_flag,
+                }, indent=2, default=str)
+            except Exception as e:
+                log_event(f"[TabularProcessingPlugin] Error counting rows: {e}", level=logging.WARNING)
+                return json.dumps({"error": str(e)})
+
+        return await asyncio.to_thread(_sync_work)
+
     @kernel_function(
         description=(
             "Execute an aggregation operation on a column of a tabular file. "
@@ -1474,6 +2576,7 @@ async def filter_rows(
         column: Annotated[str, "The column to filter on"],
         operator: Annotated[str, "Operator: ==, !=, >, <, >=, <=, contains, startswith, endswith"],
         value: Annotated[str, "The value to compare against"],
+        normalize_match: Annotated[str, "Whether to normalize string/entity matching for text comparisons (true/false)"] = "false",
         sheet_name: Annotated[Optional[str], "Optional worksheet name for Excel files. Required for analytical calls on multi-sheet workbooks unless sheet_index is provided."] = None,
         sheet_index: Annotated[Optional[str], "Optional zero-based worksheet index for Excel files. Ignored when sheet_name is provided."] = None,
         source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat",
@@ -1484,6 +2587,7 @@ async def filter_rows(
         """Filter rows based on a condition."""
         def _sync_work():
             try:
+                normalize_match_flag = self._parse_boolean_argument(normalize_match, default=False)
                 container, blob_path = self._resolve_blob_location_with_fallback(
                     user_id, conversation_id, filename, source,
                     group_id=group_id, public_workspace_id=public_workspace_id
@@ -1494,6 +2598,7 @@ def _sync_work():
                 if not normalized_sheet and normalized_sheet_idx in (None, ''):
                     cross_sheet_result = self._filter_rows_across_sheets(
                         container, blob_path, filename, column, operator, value,
+                        normalize_match=normalize_match_flag,
                         max_rows=int(max_rows),
                     )
                     if cross_sheet_result is not None:
@@ -1514,42 +2619,26 @@ def _sync_work():
                 df = self._try_numeric_conversion(df)
 
                 if column not in df.columns:
-                    return json.dumps({"error": f"Column '{column}' not found. Available: {list(df.columns)}"})
-
-                series = df[column]
-                op = operator.strip().lower()
+                    return json.dumps(
+                        self._build_missing_column_error_payload(
+                            container,
+                            blob_path,
+                            filename,
+                            workbook_metadata,
+                            selected_sheet,
+                            column,
+                            available_columns=list(df.columns),
+                        )
+                    )
 
-                numeric_value = None
                 try:
-                    numeric_value = float(value)
-                except (ValueError, TypeError):
-                    pass
-
-                if op == '==' or op == 'equals':
-                    if numeric_value is not None and pandas.api.types.is_numeric_dtype(series):
-                        mask = series == numeric_value
-                    else:
-                        mask = series.astype(str).str.lower() == value.lower()
-                elif op == '!=':
-                    if numeric_value is not None and pandas.api.types.is_numeric_dtype(series):
-                        mask = series != numeric_value
-                    else:
-                        mask = series.astype(str).str.lower() != value.lower()
-                elif op == '>':
-                    mask = series > numeric_value
-                elif op == '<':
-                    mask = series < numeric_value
-                elif op == '>=':
-                    mask = series >= numeric_value
-                elif op == '<=':
-                    mask = series <= numeric_value
-                elif op == 'contains':
-                    mask = series.astype(str).str.contains(value, case=False, na=False)
-                elif op == 'startswith':
-                    mask = series.astype(str).str.lower().str.startswith(value.lower())
-                elif op == 'endswith':
-                    mask = series.astype(str).str.lower().str.endswith(value.lower())
-                else:
+                    mask = self._build_series_match_mask(
+                        df[column],
+                        operator,
+                        value,
+                        normalize_match=normalize_match_flag,
+                    )
+                except ValueError:
                     return json.dumps({"error": f"Unsupported operator: {operator}"})
 
                 limit = int(max_rows)
@@ -1557,6 +2646,7 @@ def _sync_work():
                 return json.dumps({
                     "filename": filename,
                     "selected_sheet": selected_sheet if workbook_metadata.get('is_workbook') else None,
+                    "normalize_match": normalize_match_flag,
                     "total_matches": int(mask.sum()),
                     "returned_rows": len(filtered),
                     "data": filtered.to_dict(orient='records')
@@ -1634,6 +2724,156 @@ def _sync_work():
                 return json.dumps({"error": f"Query error: {str(e)}. Ensure column names and values are correct."})
         return await asyncio.to_thread(_sync_work)
 
+    @kernel_function(
+        description=(
+            "Filter rows in one worksheet where the target match column belongs to a cohort defined by values from another worksheet. "
+            "Use this for relational workbook questions such as facts owned by a cohort or records tied to a reference sheet membership list."
+        ),
+        name="filter_rows_by_related_values"
+    )
+    @plugin_function_logger("TabularProcessingPlugin")
+    async def filter_rows_by_related_values(
+        self,
+        user_id: Annotated[str, "The user ID (from Scope ID in Conversation Metadata)"],
+        conversation_id: Annotated[str, "The conversation ID (from Conversation Metadata)"],
+        filename: Annotated[str, "The filename of the tabular file"],
+        source_sheet_name: Annotated[str, "Worksheet that defines the cohort or reference values"],
+        source_value_column: Annotated[str, "Column on the source worksheet that contains the canonical cohort values"],
+        target_sheet_name: Annotated[str, "Worksheet containing the fact rows to filter"],
+        target_match_column: Annotated[str, "Column on the target worksheet that should match the source cohort values"],
+        source_query_expression: Annotated[Optional[str], "Optional pandas DataFrame.query() expression to narrow the source cohort"] = None,
+        source_filter_column: Annotated[Optional[str], "Optional source-sheet filter column"] = None,
+        source_filter_operator: Annotated[str, "Optional source-sheet filter operator"] = "equals",
+        source_filter_value: Annotated[Optional[str], "Optional source-sheet filter value"] = None,
+        target_query_expression: Annotated[Optional[str], "Optional pandas DataFrame.query() expression to narrow target rows before matching"] = None,
+        target_filter_column: Annotated[Optional[str], "Optional target-sheet filter column"] = None,
+        target_filter_operator: Annotated[str, "Optional target-sheet filter operator"] = "equals",
+        target_filter_value: Annotated[Optional[str], "Optional target-sheet filter value"] = None,
+        source_alias_column: Annotated[Optional[str], "Optional alternate or alias source column used for normalized matching"] = None,
+        target_alias_column: Annotated[Optional[str], "Optional alternate or alias target column used for normalized matching"] = None,
+        normalize_match: Annotated[str, "Whether to normalize entity-style text matching across worksheets (true/false)"] = "true",
+        source_sheet_index: Annotated[Optional[str], "Optional zero-based source worksheet index if sheet name is not used"] = None,
+        target_sheet_index: Annotated[Optional[str], "Optional zero-based target worksheet index if sheet name is not used"] = None,
+        source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat",
+        max_rows: Annotated[str, "Maximum related target rows to return"] = "100",
+        group_id: Annotated[Optional[str], "Group ID (for group workspace documents)"] = None,
+        public_workspace_id: Annotated[Optional[str], "Public workspace ID (for public workspace documents)"] = None,
+    ) -> Annotated[str, "JSON result containing explainable set-membership filtering output"]:
+        """Filter target rows by membership in a source-sheet cohort."""
+        def _sync_work():
+            try:
+                normalize_match_flag = self._parse_boolean_argument(normalize_match, default=True)
+                container, blob_path = self._resolve_blob_location_with_fallback(
+                    user_id, conversation_id, filename, source,
+                    group_id=group_id, public_workspace_id=public_workspace_id
+                )
+                result_payload = self._evaluate_related_value_membership(
+                    container,
+                    blob_path,
+                    filename,
+                    source_sheet_name=source_sheet_name,
+                    source_value_column=source_value_column,
+                    target_sheet_name=target_sheet_name,
+                    target_match_column=target_match_column,
+                    source_sheet_index=source_sheet_index,
+                    target_sheet_index=target_sheet_index,
+                    source_query_expression=source_query_expression,
+                    source_filter_column=source_filter_column,
+                    source_filter_operator=source_filter_operator,
+                    source_filter_value=source_filter_value,
+                    target_query_expression=target_query_expression,
+                    target_filter_column=target_filter_column,
+                    target_filter_operator=target_filter_operator,
+                    target_filter_value=target_filter_value,
+                    source_alias_column=source_alias_column,
+                    target_alias_column=target_alias_column,
+                    normalize_match=normalize_match_flag,
+                    max_rows=int(max_rows),
+                )
+                return json.dumps(result_payload, indent=2, default=str)
+            except Exception as e:
+                log_event(f"[TabularProcessingPlugin] Error filtering rows by related values: {e}", level=logging.WARNING)
+                return json.dumps({"error": str(e)})
+
+        return await asyncio.to_thread(_sync_work)
+
+    @kernel_function(
+        description=(
+            "Count rows in one worksheet where the target match column belongs to a cohort defined by another worksheet. "
+            "Use this for deterministic numerator/denominator calculations and percentages across related sheets."
+        ),
+        name="count_rows_by_related_values"
+    )
+    @plugin_function_logger("TabularProcessingPlugin")
+    async def count_rows_by_related_values(
+        self,
+        user_id: Annotated[str, "The user ID (from Scope ID in Conversation Metadata)"],
+        conversation_id: Annotated[str, "The conversation ID (from Conversation Metadata)"],
+        filename: Annotated[str, "The filename of the tabular file"],
+        source_sheet_name: Annotated[str, "Worksheet that defines the cohort or reference values"],
+        source_value_column: Annotated[str, "Column on the source worksheet that contains the canonical cohort values"],
+        target_sheet_name: Annotated[str, "Worksheet containing the fact rows to count"],
+        target_match_column: Annotated[str, "Column on the target worksheet that should match the source cohort values"],
+        source_query_expression: Annotated[Optional[str], "Optional pandas DataFrame.query() expression to narrow the source cohort"] = None,
+        source_filter_column: Annotated[Optional[str], "Optional source-sheet filter column"] = None,
+        source_filter_operator: Annotated[str, "Optional source-sheet filter operator"] = "equals",
+        source_filter_value: Annotated[Optional[str], "Optional source-sheet filter value"] = None,
+        target_query_expression: Annotated[Optional[str], "Optional pandas DataFrame.query() expression to narrow target rows before matching"] = None,
+        target_filter_column: Annotated[Optional[str], "Optional target-sheet filter column"] = None,
+        target_filter_operator: Annotated[str, "Optional target-sheet filter operator"] = "equals",
+        target_filter_value: Annotated[Optional[str], "Optional target-sheet filter value"] = None,
+        source_alias_column: Annotated[Optional[str], "Optional alternate or alias source column used for normalized matching"] = None,
+        target_alias_column: Annotated[Optional[str], "Optional alternate or alias target column used for normalized matching"] = None,
+        normalize_match: Annotated[str, "Whether to normalize entity-style text matching across worksheets (true/false)"] = "true",
+        source_sheet_index: Annotated[Optional[str], "Optional zero-based source worksheet index if sheet name is not used"] = None,
+        target_sheet_index: Annotated[Optional[str], "Optional zero-based target worksheet index if sheet name is not used"] = None,
+        source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat",
+        group_id: Annotated[Optional[str], "Group ID (for group workspace documents)"] = None,
+        public_workspace_id: Annotated[Optional[str], "Public workspace ID (for public workspace documents)"] = None,
+    ) -> Annotated[str, "JSON result containing an explainable relational row count"]:
+        """Count target rows by membership in a source-sheet cohort."""
+        def _sync_work():
+            try:
+                normalize_match_flag = self._parse_boolean_argument(normalize_match, default=True)
+                container, blob_path = self._resolve_blob_location_with_fallback(
+                    user_id, conversation_id, filename, source,
+                    group_id=group_id, public_workspace_id=public_workspace_id
+                )
+                result_payload = self._evaluate_related_value_membership(
+                    container,
+                    blob_path,
+                    filename,
+                    source_sheet_name=source_sheet_name,
+                    source_value_column=source_value_column,
+                    target_sheet_name=target_sheet_name,
+                    target_match_column=target_match_column,
+                    source_sheet_index=source_sheet_index,
+                    target_sheet_index=target_sheet_index,
+                    source_query_expression=source_query_expression,
+                    source_filter_column=source_filter_column,
+                    source_filter_operator=source_filter_operator,
+                    source_filter_value=source_filter_value,
+                    target_query_expression=target_query_expression,
+                    target_filter_column=target_filter_column,
+                    target_filter_operator=target_filter_operator,
+                    target_filter_value=target_filter_value,
+                    source_alias_column=source_alias_column,
+                    target_alias_column=target_alias_column,
+                    normalize_match=normalize_match_flag,
+                    max_rows=50,
+                )
+                if 'error' not in result_payload:
+                    result_payload['row_count'] = result_payload.get('matched_target_row_count', 0)
+                    result_payload.pop('data', None)
+                    result_payload.pop('returned_rows', None)
+                    result_payload.pop('rows_limited', None)
+                return json.dumps(result_payload, indent=2, default=str)
+            except Exception as e:
+                log_event(f"[TabularProcessingPlugin] Error counting rows by related values: {e}", level=logging.WARNING)
+                return json.dumps({"error": str(e)})
+
+        return await asyncio.to_thread(_sync_work)
+
     @kernel_function(
         description=(
             "Perform a group-by aggregation on a tabular file. "
diff --git a/docs/explanation/features/TABULAR_RELATIONAL_ANALYSIS_HELPERS.md b/docs/explanation/features/TABULAR_RELATIONAL_ANALYSIS_HELPERS.md
new file mode 100644
index 00000000..e922cb92
--- /dev/null
+++ b/docs/explanation/features/TABULAR_RELATIONAL_ANALYSIS_HELPERS.md
@@ -0,0 +1,95 @@
+# Tabular Relational Analysis Helpers
+
+## Overview
+This feature extends the tabular processing plugin with deterministic helpers for cross-sheet cohort, count, and relationship-style workbook questions. It adds distinct-value discovery, row counting, set-membership filtering and counting, normalized entity matching, and workbook relationship metadata so the analysis layer can answer relational questions without relying on sampled row counting or workbook-specific prompting.
+
+**Version Implemented:** 0.240.017
+
+## Dependencies
+- Flask chat orchestration in `route_backend_chats.py`
+- `TabularProcessingPlugin` in `semantic_kernel_plugins/tabular_processing_plugin.py`
+- Azure Blob Storage-backed workbook access
+- Azure Cosmos DB message and citation persistence
+- Existing tabular SK analysis routing and citation compaction
+
+## Architecture Overview
+
+### Plugin Enhancements
+- Added deterministic helper functions for distinct values, row counts, and cross-sheet set-membership analysis.
+- Added normalized entity matching for text comparisons such as names, owners, assignees, and engineer-style identifiers.
+- Extended workbook schema summaries with inferred `sheet_role_hints` and `relationship_hints` so orchestration can see likely reference-to-fact sheet relationships.
+
+### Orchestration Enhancements
+- Updated the tabular SK analysis prompt to advertise the new helpers.
+- Added prompt guidance that prefers deterministic count helpers over manual counting from sampled rows.
+- Added prompt guidance for cohort and ownership-share questions that span multiple worksheets.
+
+## Feature Set
+
+### `get_distinct_values`
+- Returns deterministic distinct values from a worksheet or, when appropriate, across worksheets.
+- Supports optional `query_expression` and filter conditions.
+- Supports normalized string/entity matching for stable deduplication.
+
+### `count_rows`
+- Returns a deterministic row count after optional query or filter criteria.
+- Avoids relying on the model to estimate counts from partial row payloads.
+
+### `filter_rows_by_related_values`
+- Filters a target worksheet by membership in a cohort defined on a source worksheet.
+- Returns explainable metadata including source cohort size, matched source values, unmatched source values, and matched target row count.
+
+### `count_rows_by_related_values`
+- Counts target rows by membership in a source-sheet cohort.
+- Designed for numerator/denominator and percentage-style questions across related worksheets.
+
+### Normalized Entity Matching
+- Canonicalizes text by trimming, casefolding, normalizing punctuation, and collapsing whitespace.
+- Supports optional alias columns on both source and target worksheets when available.
+
+### Workbook Relationship Metadata
+- Adds `sheet_role_hints` for likely dimension, fact, metadata, or unknown worksheet roles.
+- Adds `relationship_hints` with likely reference and fact sheets, candidate join columns, overlap counts, and overlap ratios.
+
+## File Structure
+
+| File | Purpose |
+|---|---|
+| `application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py` | New deterministic relational helpers, normalized matching, and relationship metadata inference |
+| `application/single_app/route_backend_chats.py` | Prompt guidance and schema preload exposure for the new helpers |
+| `application/single_app/functions_message_artifacts.py` | Compact citation support for the new tabular helper outputs |
+| `functional_tests/test_tabular_relational_analysis_helpers.py` | Regression coverage for relationship metadata and deterministic relational helpers |
+
+## Explainable Outputs
+
+The new relational helpers return structured metadata such as:
+- Source and target sheets
+- Source and target match columns
+- Source cohort size
+- Matched and unmatched source value counts
+- Matched target row count
+- Applied filter summaries
+- Normalization flags
+- Row truncation indicators when applicable
+
+## Testing and Validation
+
+### Covered Scenarios
+- Workbook schema summaries infer likely reference/fact relationships.
+- Distinct-value discovery returns a deterministic filtered cohort.
+- Deterministic row counting returns explicit counts rather than sampled approximations.
+- Cross-sheet set-membership helpers return explainable outputs and normalized matching works across owner/name variants.
+- Tabular SK prompt guidance advertises and prefers the new deterministic helpers.
+
+### Functional Test
+- `functional_tests/test_tabular_relational_analysis_helpers.py`
+
+## Known Tradeoffs
+- Relationship hints are heuristic and intended to guide tool choice, not to prove a guaranteed join.
+- Normalized matching improves robustness for entity-style text, but ambiguous aliases still depend on the workbook data being reasonably consistent.
+- The new helpers reduce reasoning ambiguity, but they do not replace the existing large-dataset artifact and prompt-budget protections.
+
+## Cross-References
+- `docs/explanation/fixes/ASSISTANT_CITATION_ARTIFACT_STORAGE_FIX.md`
+- `docs/explanation/fixes/TABULAR_PROMPT_BUDGET_FALLBACK_FIX.md`
+- `docs/explanation/features/TABULAR_LARGE_DATASET_ANALYSIS_REDESIGN_PLAN.md`
\ No newline at end of file
diff --git a/functional_tests/test_tabular_relational_analysis_helpers.py b/functional_tests/test_tabular_relational_analysis_helpers.py
new file mode 100644
index 00000000..5517c84f
--- /dev/null
+++ b/functional_tests/test_tabular_relational_analysis_helpers.py
@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+# test_tabular_relational_analysis_helpers.py
+"""
+Functional test for tabular relational analysis helpers.
+Version: 0.240.017
+Implemented in: 0.240.017
+
+This test ensures the tabular processing plugin can infer workbook relationship
+metadata, return deterministic distinct values and row counts, and perform
+explainable set-membership filtering and counting across related worksheets.
+"""
+
+import asyncio
+import importlib.util
+import json
+import os
+import sys
+
+import pandas as pd
+
+
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(ROOT_DIR)
+sys.path.append(os.path.join(ROOT_DIR, 'application', 'single_app'))
+
+PLUGIN_FILE = os.path.join(
+    ROOT_DIR,
+    'application',
+    'single_app',
+    'semantic_kernel_plugins',
+    'tabular_processing_plugin.py',
+)
+ROUTE_FILE = os.path.join(ROOT_DIR, 'application', 'single_app', 'route_backend_chats.py')
+
+PLUGIN_SPEC = importlib.util.spec_from_file_location('tabular_processing_plugin', PLUGIN_FILE)
+PLUGIN_MODULE = importlib.util.module_from_spec(PLUGIN_SPEC)
+PLUGIN_SPEC.loader.exec_module(PLUGIN_MODULE)
+TabularProcessingPlugin = PLUGIN_MODULE.TabularProcessingPlugin
+
+
+def build_mock_workbook_plugin():
+    """Create a plugin backed by in-memory workbook frames."""
+    plugin = TabularProcessingPlugin()
+    container_name = 'mock-container'
+    blob_name = 'milestone_relationships.xlsx'
+
+    engineer_frame = pd.DataFrame({
+        'EngineerName': ['Paul Lizer', 'Alicia Stone', 'Morgan Lee'],
+        'EngineerAlias': ['Paul-Lizer', '', ''],
+        'Team': ['SE', 'SE', 'CSM'],
+    })
+    milestone_rows = [
+        {'MilestoneID': f'MS{index:03d}', 'Owner': 'PAUL LIZER', 'OwnerAlias': '', 'MilestoneStatus': 'Open'}
+        for index in range(1, 16)
+    ]
+    milestone_rows.extend([
+        {'MilestoneID': f'MS{index:03d}', 'Owner': 'Paul-Lizer', 'OwnerAlias': 'Paul Lizer', 'MilestoneStatus': 'Open'}
+        for index in range(16, 21)
+    ])
+    milestone_rows.extend([
+        {'MilestoneID': f'MS{index:03d}', 'Owner': 'Alicia Stone', 'OwnerAlias': '', 'MilestoneStatus': 'Open'}
+        for index in range(21, 31)
+    ])
+    milestone_rows.extend([
+        {'MilestoneID': f'MS{index:03d}', 'Owner': 'Morgan Lee', 'OwnerAlias': '', 'MilestoneStatus': 'Closed'}
+        for index in range(31, 36)
+    ])
+    milestone_rows.extend([
+        {'MilestoneID': f'MS{index:03d}', 'Owner': 'Jamie Roe', 'OwnerAlias': '', 'MilestoneStatus': 'Open'}
+        for index in range(36, 41)
+    ])
+
+    workbook_frames = {
+        'solution_engineers': engineer_frame,
+        'milestones': pd.DataFrame(milestone_rows),
+        'metadata': pd.DataFrame({'RefreshDate': ['2026-04-02'], 'Source': ['unit-test']}),
+    }
+    workbook_metadata = {
+        'is_workbook': True,
+        'sheet_names': ['solution_engineers', 'milestones', 'metadata'],
+        'sheet_count': 3,
+        'default_sheet': 'solution_engineers',
+    }
+
+    plugin._resolve_blob_location_with_fallback = lambda *args, **kwargs: (container_name, blob_name)
+    plugin._get_workbook_metadata = lambda *args, **kwargs: workbook_metadata.copy()
+
+    def read_dataframe(container, blob, sheet_name=None, sheet_index=None, require_explicit_sheet=False):
+        selected_sheet, _ = plugin._resolve_sheet_selection(
+            container,
+            blob,
+            sheet_name=sheet_name,
+            sheet_index=sheet_index,
+            require_explicit_sheet=require_explicit_sheet,
+        )
+        return workbook_frames[selected_sheet].copy()
+
+    plugin._read_tabular_blob_to_dataframe = read_dataframe
+    return plugin
+
+
+def test_describe_tabular_file_infers_relationship_hints():
+    """Verify workbook schema summaries include role and relationship hints."""
+    print('🔍 Testing workbook relationship metadata...')
+
+    try:
+        plugin = build_mock_workbook_plugin()
+        payload = json.loads(asyncio.run(plugin.describe_tabular_file(
+            user_id='test-user',
+            conversation_id='test-conversation',
+            filename='milestone_relationships.xlsx',
+            source='workspace',
+        )))
+
+        assert payload['is_workbook'] is True, payload
+        assert payload['sheet_role_hints']['solution_engineers']['role'] == 'dimension', payload
+        assert payload['sheet_role_hints']['milestones']['role'] == 'fact', payload
+        relationship_hints = payload.get('relationship_hints', [])
+        assert relationship_hints, payload
+        top_hint = relationship_hints[0]
+        assert top_hint['reference_sheet'] == 'solution_engineers', top_hint
+        assert top_hint['fact_sheet'] == 'milestones', top_hint
+        assert top_hint['normalized_overlap_count'] >= 2, top_hint
+
+        print('✅ Workbook relationship metadata passed')
+        return True
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_get_distinct_values_returns_canonical_cohort():
+    """Verify deterministic distinct values can build a filtered cohort."""
+    print('🔍 Testing deterministic distinct values...')
+
+    try:
+        plugin = build_mock_workbook_plugin()
+        payload = json.loads(asyncio.run(plugin.get_distinct_values(
+            user_id='test-user',
+            conversation_id='test-conversation',
+            filename='milestone_relationships.xlsx',
+            sheet_name='solution_engineers',
+            column='EngineerName',
+            filter_column='Team',
+            filter_operator='equals',
+            filter_value='SE',
+            normalize_match='true',
+            source='workspace',
+        )))
+
+        assert payload['selected_sheet'] == 'solution_engineers', payload
+        assert payload['distinct_count'] == 2, payload
+        assert payload['values'] == ['Alicia Stone', 'Paul Lizer'], payload
+
+        print('✅ Deterministic distinct values passed')
+        return True
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_count_rows_returns_deterministic_row_count():
+    """Verify the plugin returns an explicit row count after filtering."""
+    print('🔍 Testing deterministic row counts...')
+
+    try:
+        plugin = build_mock_workbook_plugin()
+        payload = json.loads(asyncio.run(plugin.count_rows(
+            user_id='test-user',
+            conversation_id='test-conversation',
+            filename='milestone_relationships.xlsx',
+            sheet_name='milestones',
+            filter_column='MilestoneStatus',
+            filter_operator='equals',
+            filter_value='Open',
+            source='workspace',
+        )))
+
+        assert payload['selected_sheet'] == 'milestones', payload
+        assert payload['row_count'] == 35, payload
+        assert payload['rows_scanned'] == 40, payload
+
+        print('✅ Deterministic row counts passed')
+        return True
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_related_value_helpers_return_explainable_outputs():
+    """Verify semi-join helpers return deterministic counts and explainable metadata."""
+    print('🔍 Testing related-value semi-join helpers...')
+
+    try:
+        plugin = build_mock_workbook_plugin()
+        count_payload = json.loads(asyncio.run(plugin.count_rows_by_related_values(
+            user_id='test-user',
+            conversation_id='test-conversation',
+            filename='milestone_relationships.xlsx',
+            source_sheet_name='solution_engineers',
+            source_value_column='EngineerName',
+            source_alias_column='EngineerAlias',
+            source_filter_column='Team',
+            source_filter_operator='equals',
+            source_filter_value='SE',
+            target_sheet_name='milestones',
+            target_match_column='Owner',
+            target_alias_column='OwnerAlias',
+            target_filter_column='MilestoneStatus',
+            target_filter_operator='equals',
+            target_filter_value='Open',
+            normalize_match='true',
+            source='workspace',
+        )))
+        filter_payload = json.loads(asyncio.run(plugin.filter_rows_by_related_values(
+            user_id='test-user',
+            conversation_id='test-conversation',
+            filename='milestone_relationships.xlsx',
+            source_sheet_name='solution_engineers',
+            source_value_column='EngineerName',
+            source_alias_column='EngineerAlias',
+            source_filter_column='Team',
+            source_filter_operator='equals',
+            source_filter_value='SE',
+            target_sheet_name='milestones',
+            target_match_column='Owner',
+            target_alias_column='OwnerAlias',
+            target_filter_column='MilestoneStatus',
+            target_filter_operator='equals',
+            target_filter_value='Open',
+            normalize_match='true',
+            max_rows='5',
+            source='workspace',
+        )))
+
+        assert count_payload['source_cohort_size'] == 2, count_payload
+        assert count_payload['matched_source_value_count'] == 2, count_payload
+        assert count_payload['unmatched_source_value_count'] == 0, count_payload
+        assert count_payload['row_count'] == 30, count_payload
+        assert filter_payload['matched_target_row_count'] == 30, filter_payload
+        assert filter_payload['returned_rows'] == 5, filter_payload
+        assert filter_payload['rows_limited'] is True, filter_payload
+        assert filter_payload['data'][0]['_matched_on'], filter_payload
+
+        print('✅ Related-value semi-join helpers passed')
+        return True
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_route_prompt_mentions_deterministic_relational_helpers():
+    """Verify the analysis prompt advertises the new deterministic helper flow."""
+    print('🔍 Testing route prompt guidance for relational helpers...')
+
+    try:
+        with open(ROUTE_FILE, 'r', encoding='utf-8') as file_handle:
+            route_content = file_handle.read()
+
+        checks = {
+            'distinct helper advertised': 'get_distinct_values' in route_content,
+            'count helper advertised': 'count_rows' in route_content,
+            'related filter helper advertised': 'filter_rows_by_related_values' in route_content,
+            'related count helper advertised': 'count_rows_by_related_values' in route_content,
+            'cohort guidance exists': 'For cohort, membership, ownership-share, or percentage questions where one sheet defines the group and another sheet contains the fact rows' in route_content,
+            'deterministic count guidance exists': 'For deterministic how-many questions, use count_rows instead of estimating counts from partial returned rows.' in route_content,
+            'relationship hints exposed in schema preload': "'relationship_hints': schema_info.get('relationship_hints', [])[:5]" in route_content,
+        }
+
+        failed_checks = [name for name, passed in checks.items() if not passed]
+        assert not failed_checks, f'Missing expected relational helper guidance: {failed_checks}'
+
+        print('✅ Route prompt guidance for relational helpers passed')
+        return True
+    except Exception as exc:
+        print(f'❌ Test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == '__main__':
+    tests = [
+        test_describe_tabular_file_infers_relationship_hints,
+        test_get_distinct_values_returns_canonical_cohort,
+        test_count_rows_returns_deterministic_row_count,
+        test_related_value_helpers_return_explainable_outputs,
+        test_route_prompt_mentions_deterministic_relational_helpers,
+    ]
+    results = []
+
+    for test in tests:
+        print(f'\n🧪 Running {test.__name__}...')
+        results.append(test())
+
+    success = all(results)
+    print(f'\n📊 Results: {sum(results)}/{len(results)} tests passed')
+    sys.exit(0 if success else 1)
\ No newline at end of file

From b66cbbf1dacdb0bd0ed0e6fac7c186b96139ef45 Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 09:47:51 -0400
Subject: [PATCH 07/12] multi-tab analysis improvement and citation improvement
 for large datasets
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

What we did in part one was move the large raw tabular/tool payloads off the main assistant message and store them as linked child records instead. The core code is in functions_message_artifacts.py. We added helpers to:

Build a compact citation that stays on the assistant message.
Store the full raw citation payload in separate assistant_artifact records, with assistant_artifact_chunk records if the payload is large enough to need chunking.
Rehydrate those raw payloads later when an export or deep inspection needs the full data again.
In practice, that meant the assistant message no longer carried the full tabular function_result blob. It only kept a summary like tool name, compact arguments, counts, and a few sample rows. The heavy payload was externalized with an artifact_id and raw_payload_externalized=True. That is the “large assistant-side payloads outside primary chat items” change you’re remembering.

The chat write path was updated in route_backend_chats.py to persist those artifact records via persist_agent_citation_artifacts(...). The normal conversation/history paths were updated to hide those artifact records from visible chat history with filter_assistant_artifact_items(...) in route_backend_conversations.py and route_frontend_conversations.py. Export paths were updated to stitch the raw payload back together with build_message_artifact_payload_map(...) and hydrate_agent_citations_from_artifacts(...) in route_backend_conversation_export.py.

Why that helped performance and reliability:

It kept the main assistant message much smaller.
It prevented large tabular citations from pushing a single Cosmos message item over size limits.
It reduced the amount of heavy citation data carried around in normal chat reads/history assembly.
It preserved the raw data for export/debugging instead of throwing it away.
A few extra size cuts were part of that same phase:

We compacted stored citation summaries instead of keeping the full raw result on the main message.
We excluded noisy args like user_id, conversation_id, and source from compact tabular citation arguments in functions_message_artifacts.py.
We also removed the duplicate user_message field from assistant message docs, as called out in ASSISTANT_CITATION_ARTIFACT_STORAGE_FIX.md.
---
 application/single_app/config.py              |  2 +-
 .../single_app/functions_message_artifacts.py | 10 ++++
 application/single_app/route_backend_chats.py | 27 +++++-----
 .../tabular_processing_plugin.py              | 37 ++++++++++++-
 ...TABULAR_NAMED_MEMBER_SHARE_SEMIJOIN_FIX.md | 53 +++++++++++++++++++
 ...est_tabular_relational_analysis_helpers.py | 12 ++++-
 6 files changed, 124 insertions(+), 17 deletions(-)
 create mode 100644 docs/explanation/fixes/TABULAR_NAMED_MEMBER_SHARE_SEMIJOIN_FIX.md

diff --git a/application/single_app/config.py b/application/single_app/config.py
index e5b057c1..0e240843 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.017"
+VERSION = "0.240.018"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/functions_message_artifacts.py b/application/single_app/functions_message_artifacts.py
index eeda4057..cf57412d 100644
--- a/application/single_app/functions_message_artifacts.py
+++ b/application/single_app/functions_message_artifacts.py
@@ -327,6 +327,8 @@ def _compact_tabular_result_payload(function_name: str, payload: Any) -> Any:
         'source_cohort_size',
         'matched_source_value_count',
         'unmatched_source_value_count',
+        'source_value_match_counts_returned',
+        'source_value_match_counts_limited',
         'matched_target_row_count',
         'total_matches',
         'returned_rows',
@@ -352,6 +354,14 @@ def _compact_tabular_result_payload(function_name: str, payload: Any) -> Any:
     if isinstance(payload.get('details'), list):
         summary['details'] = _compact_value(payload.get('details'), depth=1)
 
+    source_value_match_counts = payload.get('source_value_match_counts')
+    if isinstance(source_value_match_counts, list) and source_value_match_counts:
+        summary['source_value_match_counts'] = [
+            _compact_value(item, depth=1)
+            for item in source_value_match_counts[:10]
+        ]
+        summary['source_value_match_counts_sample_limited'] = len(source_value_match_counts) > 10
+
     data_rows = payload.get('data')
     if isinstance(data_rows, list) and data_rows:
         summary['sample_rows'] = [_compact_value(row, depth=1) for row in data_rows[:3]]
diff --git a/application/single_app/route_backend_chats.py b/application/single_app/route_backend_chats.py
index e01f5b64..f7052d3d 100644
--- a/application/single_app/route_backend_chats.py
+++ b/application/single_app/route_backend_chats.py
@@ -2080,19 +2080,20 @@ def build_system_prompt(force_tool_use=False, tool_error_messages=None, executio
                 "5. If lookup_value is not sufficient, use filter_rows or query_tabular_data on the label column, then read the requested period column.\n"
                 "6. For deterministic how-many questions, use count_rows instead of estimating counts from partial returned rows.\n"
                 "7. For cohort, membership, ownership-share, or percentage questions where one sheet defines the group and another sheet contains the fact rows, use get_distinct_values, filter_rows_by_related_values, or count_rows_by_related_values.\n"
-                "8. Use normalize_match=true when matching names, owners, assignees, engineers, or similar entity-text columns across worksheets.\n"
-                "9. Only use aggregate_column when the user explicitly asks for a sum, average, min, max, or count across rows and count_rows is not the simpler deterministic option.\n"
-                "10. For time-based questions on datetime columns, use group_by_datetime_component.\n"
-                "11. For threshold, ranking, comparison, or correlation-like questions, first filter/query the relevant rows, then compute grouped metrics.\n"
-                "12. When the question asks for grouped results for each entity or category and a cross-sheet bridge plan or relationship hint is available, use the reference worksheet to identify the canonical entities or categories and the fact worksheet to compute the metric. Do not answer 'each X' by grouping a yes/no, boolean, or membership-flag column unless the user explicitly asked about that flag.\n"
-                "13. When the question asks for rows satisfying multiple conditions, prefer one combined query_expression using and/or instead of separate broad queries that you plan to intersect later.\n"
-                "14. Batch multiple independent function calls in a SINGLE response whenever possible.\n"
-                "15. Keep max_rows as small as possible. Only increase it when the user explicitly asked for an exhaustive row list or export; otherwise return total_matches plus representative rows.\n"
-                "16. For analytical questions, prefer deterministic counts plus lookup/filter/query/grouped computations over raw row or preview output.\n"
-                "17. For identifier-based workbook questions, locate the identifier on the correct sheet before explaining downstream calculations.\n"
-                "18. For peak, busiest, highest, or lowest questions, use grouped functions and inspect the highest_group, highest_value, lowest_group, and lowest_value summary fields.\n"
-                "19. Return only computed findings and name the strongest drivers clearly.\n"
-                "20. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report.\n"
+                "8. When the question asks for one named member's share within that cohort, prefer count_rows_by_related_values and either read source_value_match_counts from the helper result or rerun count_rows_by_related_values with source_filter_column/source_filter_value on the reference sheet. Do not fall back to query_tabular_data or filter_rows on the fact sheet with a guessed exact text value unless the workbook already exposed that canonical target value.\n"
+                "9. Use normalize_match=true when matching names, owners, assignees, engineers, or similar entity-text columns across worksheets.\n"
+                "10. Only use aggregate_column when the user explicitly asks for a sum, average, min, max, or count across rows and count_rows is not the simpler deterministic option.\n"
+                "11. For time-based questions on datetime columns, use group_by_datetime_component.\n"
+                "12. For threshold, ranking, comparison, or correlation-like questions, first filter/query the relevant rows, then compute grouped metrics.\n"
+                "13. When the question asks for grouped results for each entity or category and a cross-sheet bridge plan or relationship hint is available, use the reference worksheet to identify the canonical entities or categories and the fact worksheet to compute the metric. Do not answer 'each X' by grouping a yes/no, boolean, or membership-flag column unless the user explicitly asked about that flag.\n"
+                "14. When the question asks for rows satisfying multiple conditions, prefer one combined query_expression using and/or instead of separate broad queries that you plan to intersect later.\n"
+                "15. Batch multiple independent function calls in a SINGLE response whenever possible.\n"
+                "16. Keep max_rows as small as possible. Only increase it when the user explicitly asked for an exhaustive row list or export; otherwise return total_matches plus representative rows.\n"
+                "17. For analytical questions, prefer deterministic counts plus lookup/filter/query/grouped computations over raw row or preview output.\n"
+                "18. For identifier-based workbook questions, locate the identifier on the correct sheet before explaining downstream calculations.\n"
+                "19. For peak, busiest, highest, or lowest questions, use grouped functions and inspect the highest_group, highest_value, lowest_group, and lowest_value summary fields.\n"
+                "20. Return only computed findings and name the strongest drivers clearly.\n"
+                "21. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report.\n"
                 "21. When using query_tabular_data, use simple DataFrame.query() syntax with backticked column names for columns containing spaces. Avoid method calls such as .str.lower(), .astype(...), or other Python expressions that DataFrame.query() may reject."
             )
 
diff --git a/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py b/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
index 3dc84a04..cf7fc663 100644
--- a/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
+++ b/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py
@@ -103,6 +103,7 @@ class TabularProcessingPlugin:
     RELATIONSHIP_HINT_LIMIT = 10
     RELATIONSHIP_VALUE_SAMPLE_LIMIT = 500
     RELATIONSHIP_SHARED_VALUE_LIMIT = 5
+    SOURCE_VALUE_MATCH_COUNT_LIMIT = 100
 
     def __init__(self):
         self._df_cache = {}  # Per-instance cache: (container, blob_name, sheet_name) -> DataFrame
@@ -905,6 +906,7 @@ def _evaluate_related_value_membership(
             }
 
         source_member_map = {}
+        variant_to_source_keys = {}
         for _, source_row in filtered_source_df.iterrows():
             display_value = str(source_row.get(source_value_column, '')).strip()
             value_variants = set()
@@ -931,9 +933,12 @@ def _evaluate_related_value_membership(
                 {
                     'display_value': display_value or primary_key,
                     'value_variants': set(),
+                    'matched_target_row_count': 0,
                 },
             )
             existing_member['value_variants'].update(value_variants)
+            for value_variant in value_variants:
+                variant_to_source_keys.setdefault(value_variant, set()).add(primary_key)
 
         source_compare_values = set()
         for source_member in source_member_map.values():
@@ -957,19 +962,46 @@ def _evaluate_related_value_membership(
             if not matched_variants:
                 continue
 
+            matched_source_keys = sorted({
+                source_key
+                for matched_variant in matched_variants
+                for source_key in variant_to_source_keys.get(matched_variant, set())
+            })
+            if not matched_source_keys:
+                continue
+
             matched_target_value_variants.update(matched_variants)
+            for source_key in matched_source_keys:
+                source_member_map[source_key]['matched_target_row_count'] += 1
+
             matched_row_payload = target_row.to_dict()
             matched_row_payload['_matched_on'] = matched_variants[:3]
+            matched_row_payload['_matched_source_values'] = [
+                source_member_map[source_key]['display_value']
+                for source_key in matched_source_keys[:3]
+            ]
             matched_target_rows.append(matched_row_payload)
 
         matched_source_values = []
         unmatched_source_values = []
         for source_member in source_member_map.values():
-            if source_member['value_variants'] & matched_target_value_variants:
+            if source_member['matched_target_row_count'] > 0:
                 matched_source_values.append(source_member['display_value'])
             else:
                 unmatched_source_values.append(source_member['display_value'])
 
+        source_value_match_counts = sorted(
+            [
+                {
+                    'source_value': source_member['display_value'],
+                    'matched_target_row_count': source_member['matched_target_row_count'],
+                }
+                for source_member in source_member_map.values()
+            ],
+            key=lambda item: (-item['matched_target_row_count'], item['source_value'].casefold())
+        )
+        source_value_match_count_limit = self.SOURCE_VALUE_MATCH_COUNT_LIMIT
+
         matched_target_row_count = len(matched_target_rows)
         return {
             'filename': filename,
@@ -989,6 +1021,9 @@ def _evaluate_related_value_membership(
             'matched_source_values_sample': matched_source_values[:10],
             'unmatched_source_value_count': len(unmatched_source_values),
             'unmatched_source_values_sample': unmatched_source_values[:10],
+            'source_value_match_counts_returned': min(len(source_value_match_counts), source_value_match_count_limit),
+            'source_value_match_counts_limited': len(source_value_match_counts) > source_value_match_count_limit,
+            'source_value_match_counts': source_value_match_counts[:source_value_match_count_limit],
             'target_rows_scanned': len(filtered_target_df),
             'matched_target_row_count': matched_target_row_count,
             'returned_rows': min(matched_target_row_count, max_rows),
diff --git a/docs/explanation/fixes/TABULAR_NAMED_MEMBER_SHARE_SEMIJOIN_FIX.md b/docs/explanation/fixes/TABULAR_NAMED_MEMBER_SHARE_SEMIJOIN_FIX.md
new file mode 100644
index 00000000..08b8bfb1
--- /dev/null
+++ b/docs/explanation/fixes/TABULAR_NAMED_MEMBER_SHARE_SEMIJOIN_FIX.md
@@ -0,0 +1,53 @@
+# Tabular Named-Member Share Semi-Join Fix
+
+Fixed in version: **0.240.018**
+
+## Issue Description
+
+Cross-sheet ownership-share questions could compute the total cohort count correctly with `count_rows_by_related_values` but still miss the named member's count.
+
+Example pattern:
+
+- One sheet defines the cohort, such as `solution_engineers`
+- Another sheet contains the fact rows, such as `milestones_analysis`
+- The user asks for both the cohort total and one named member's share of that total
+
+In that flow, the model could correctly compute the total using the normalized semi-join helper, then fall back to an exact `query_tabular_data` equality check on the fact sheet for the named member. That exact-string fallback could miss valid rows when the workbook used a different casing, alias, or canonical owner form.
+
+## Root Cause Analysis
+
+- `count_rows_by_related_values` returned cohort-level totals and matched/unmatched source-member samples, but not a deterministic per-source count breakdown.
+- The model therefore needed a second step to answer the named-member portion of the question.
+- In the failing path, that second step used a fact-sheet exact text query instead of staying on the normalized source-to-target semi-join path.
+
+## Files Modified
+
+- `application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py`
+- `application/single_app/route_backend_chats.py`
+- `application/single_app/functions_message_artifacts.py`
+- `functional_tests/test_tabular_relational_analysis_helpers.py`
+- `application/single_app/config.py`
+
+## Code Changes Summary
+
+- Added deterministic `source_value_match_counts` output to the related-value semi-join helper so each source cohort member can be paired with its matched target row count.
+- Added `_matched_source_values` to returned target-row samples for clearer explainability.
+- Updated analysis prompt guidance so named-member share questions prefer the semi-join helper result or a source-side filtered rerun instead of an exact fact-sheet text query.
+- Extended compact artifact summaries so the new per-source breakdown is preserved in stored tabular citations.
+- Added regression assertions covering the per-source breakdown and prompt guidance.
+
+## Testing Approach
+
+- Updated `functional_tests/test_tabular_relational_analysis_helpers.py` to verify deterministic per-source counts for a cross-sheet solution-engineer cohort.
+- Re-ran existing workbook regressions to confirm the fix did not regress multi-sheet lookup behavior.
+
+## Validation
+
+- `functional_tests/test_tabular_relational_analysis_helpers.py` passed.
+- `functional_tests/test_tabular_multisheet_workbook_support.py` passed.
+- `functional_tests/test_tabular_cross_sheet_bridge_analysis.py` passed.
+
+## Impact Analysis
+
+- Named-member ownership-share and percentage questions now stay on the normalized semi-join path instead of depending on a fragile exact-string fallback.
+- The fix is generic to cross-sheet cohort and ownership-share questions and is not specific to a single workbook.
\ No newline at end of file
diff --git a/functional_tests/test_tabular_relational_analysis_helpers.py b/functional_tests/test_tabular_relational_analysis_helpers.py
index 5517c84f..70aaa80f 100644
--- a/functional_tests/test_tabular_relational_analysis_helpers.py
+++ b/functional_tests/test_tabular_relational_analysis_helpers.py
@@ -2,8 +2,8 @@
 # test_tabular_relational_analysis_helpers.py
 """
 Functional test for tabular relational analysis helpers.
-Version: 0.240.017
-Implemented in: 0.240.017
+Version: 0.240.018
+Implemented in: 0.240.018
 
 This test ensures the tabular processing plugin can infer workbook relationship
 metadata, return deterministic distinct values and row counts, and perform
@@ -243,10 +243,17 @@ def test_related_value_helpers_return_explainable_outputs():
         assert count_payload['matched_source_value_count'] == 2, count_payload
         assert count_payload['unmatched_source_value_count'] == 0, count_payload
         assert count_payload['row_count'] == 30, count_payload
+        assert count_payload['source_value_match_counts_returned'] == 2, count_payload
+        assert count_payload['source_value_match_counts_limited'] is False, count_payload
+        assert count_payload['source_value_match_counts'] == [
+            {'source_value': 'Paul Lizer', 'matched_target_row_count': 20},
+            {'source_value': 'Alicia Stone', 'matched_target_row_count': 10},
+        ], count_payload
         assert filter_payload['matched_target_row_count'] == 30, filter_payload
         assert filter_payload['returned_rows'] == 5, filter_payload
         assert filter_payload['rows_limited'] is True, filter_payload
         assert filter_payload['data'][0]['_matched_on'], filter_payload
+        assert filter_payload['data'][0]['_matched_source_values'], filter_payload
 
         print('✅ Related-value semi-join helpers passed')
         return True
@@ -271,6 +278,7 @@ def test_route_prompt_mentions_deterministic_relational_helpers():
             'related filter helper advertised': 'filter_rows_by_related_values' in route_content,
             'related count helper advertised': 'count_rows_by_related_values' in route_content,
             'cohort guidance exists': 'For cohort, membership, ownership-share, or percentage questions where one sheet defines the group and another sheet contains the fact rows' in route_content,
+            'named member share guidance exists': "When the question asks for one named member's share within that cohort" in route_content,
             'deterministic count guidance exists': 'For deterministic how-many questions, use count_rows instead of estimating counts from partial returned rows.' in route_content,
             'relationship hints exposed in schema preload': "'relationship_hints': schema_info.get('relationship_hints', [])[:5]" in route_content,
         }

From 21e8bfaf8f1a258811bd1904fc8c9cc679f043c5 Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 09:57:18 -0400
Subject: [PATCH 08/12] Update release_notes.md

---
 docs/explanation/release_notes.md | 48 +++++++++++--------------------
 1 file changed, 17 insertions(+), 31 deletions(-)

diff --git a/docs/explanation/release_notes.md b/docs/explanation/release_notes.md
index de15c76e..7a5ee672 100644
--- a/docs/explanation/release_notes.md
+++ b/docs/explanation/release_notes.md
@@ -3,40 +3,10 @@
 # Feature Release
 
 This page tracks notable Simple Chat releases and organizes the detailed change log by version. The timeline below provides a quick visual overview of the current release progression through v0.240.001, and the per-version entries continue immediately after it.
-### **(v0.240.016)**
-
-#### Bug Fixes
-
-*   **Python Runtime Dependency Refresh and Supply-Chain Hardening**
-    *   Continued the requirements hardening work from `v0.240.014` by tightening the main application runtime to exact package pins, reducing dependency drift across local development, CI, and Azure deployments to help mitigate supply-chain exposure.
-    *   Upgraded the Flask runtime stack to `Flask==3.1.3` and `Werkzeug==3.1.6`, and updated the shared `Markup` import path to `markupsafe` so the app starts correctly with Flask 3's package boundary changes.
-    *   Refreshed key runtime dependencies including `gunicorn`, `requests`, `openai`, `Markdown`, `markdown2`, `azure-ai-projects`, `azure-ai-agents`, `pyjwt`, `pypdf`, `semantic-kernel`, `protobuf`, `redis`, `pyodbc`, `PyMySQL`, `cython`, and `aiohttp` to pick up current security, compatibility, and capability improvements while keeping builds reproducible.
-    *   (Ref: `application/single_app/requirements.txt`, `application/single_app/config.py`, `functional_tests/test_flask_markup_import_fix.py`, `docs/explanation/fixes/FLASK_31_MARKUP_IMPORT_FIX.md`)
-
-### **(v0.240.014)**
-
-#### Bug Fixes
-
-*   **Dependency Pinning and Requirements Hardening**
-    *   Pinned previously floating Python package requirements to exact versions across the main app, UI test, deployer, and external app requirement files to reduce unexpected dependency drift and tighten supply-chain control.
-    *   Corrected stale external app dependency entries by replacing `dotenv` with `python-dotenv`, removing the stdlib-only `logging` package, removing an unused `Flask` requirement from the databaseseeder utility, and adding `pytest-playwright` so the UI test dependency set matches the pytest fixture usage in the test suite.
-    *   (Ref: `application/single_app/requirements.txt`, `ui_tests/requirements.txt`, `deployers/bicep/requirements.txt`, `application/external_apps/databaseseeder/requirements.txt`, `application/external_apps/bulkloader/requirements.txt`)
-
-### **(v0.240.004)**
-
-#### New Features
-
-*   **Cross-Cloud Deployment Improvements**
-    *   Updated the Azure CLI, AZD, Bicep, and Terraform deployment paths to better align with the current SimpleChat runtime configuration and reduce post-deployment manual fixes.
-    *   Added optional Azure Video Indexer deployment support with cloud-aware defaults, including the correct endpoint and ARM API version handling for Azure Commercial, Azure Government, and registered custom clouds.
-    *   (Ref: `deployers/azure.yaml`, `deployers/azurecli/deploy-simplechat.ps1`, `deployers/bicep/main.bicep`, `deployers/bicep/modules/videoIndexer.bicep`, `deployers/terraform/main.tf`, `application/single_app/functions_settings.py`)
-### **(v0.239.187)**
 
 For feature-focused and fix-focused drill-downs by version, see [Features by Version](/explanation/features/) and [Fixes by Version](/explanation/fixes/).
 
-![Simple Chat release timeline](../images/release-timeline.png)
-
-### **(v0.240.001)**
+### **(v0.240.016)**
 
 #### New Features
 
@@ -189,6 +159,11 @@ For feature-focused and fix-focused drill-downs by version, see [Features by Ver
     *   New admin setting fields: `redis_auth_type` (values: `key`, `managed_identity`, `key_vault`) and `redis_key` (used as the Key Vault secret name when `key_vault` auth type is selected).
     *   **Files Modified**: `app_settings_cache.py`, `app.py` `configure_sessions`, `route_backend_settings.py` `_test_redis_connection`, `functions_keyvault.py` `retrieve_secret_direct`
 
+*   **Cross-Cloud Deployment Improvements**
+    *   Updated the Azure CLI, AZD, Bicep, and Terraform deployment paths to better align with the current SimpleChat runtime configuration and reduce post-deployment manual fixes.
+    *   Added optional Azure Video Indexer deployment support with cloud-aware defaults, including the correct endpoint and ARM API version handling for Azure Commercial, Azure Government, and registered custom clouds.
+    *   (Ref: `deployers/azure.yaml`, `deployers/azurecli/deploy-simplechat.ps1`, `deployers/bicep/main.bicep`, `deployers/bicep/modules/videoIndexer.bicep`, `deployers/terraform/main.tf`, `application/single_app/functions_settings.py`)
+
 #### User Interface Enhancements
 
 *   **Agent Responded Thought — Seconds & Total Duration**
@@ -232,6 +207,17 @@ For feature-focused and fix-focused drill-downs by version, see [Features by Ver
     
 #### Bug Fixes
 
+*   **Python Runtime Dependency Refresh and Supply-Chain Hardening**
+    *   Continued the requirements hardening work from `v0.240.014` by tightening the main application runtime to exact package pins, reducing dependency drift across local development, CI, and Azure deployments to help mitigate supply-chain exposure.
+    *   Upgraded the Flask runtime stack to `Flask==3.1.3` and `Werkzeug==3.1.6`, and updated the shared `Markup` import path to `markupsafe` so the app starts correctly with Flask 3's package boundary changes.
+    *   Refreshed key runtime dependencies including `gunicorn`, `requests`, `openai`, `Markdown`, `markdown2`, `azure-ai-projects`, `azure-ai-agents`, `pyjwt`, `pypdf`, `semantic-kernel`, `protobuf`, `redis`, `pyodbc`, `PyMySQL`, `cython`, and `aiohttp` to pick up current security, compatibility, and capability improvements while keeping builds reproducible.
+    *   (Ref: `application/single_app/requirements.txt`, `application/single_app/config.py`, `functional_tests/test_flask_markup_import_fix.py`, `docs/explanation/fixes/FLASK_31_MARKUP_IMPORT_FIX.md`)
+
+*   **Dependency Pinning and Requirements Hardening**
+    *   Pinned previously floating Python package requirements to exact versions across the main app, UI test, deployer, and external app requirement files to reduce unexpected dependency drift and tighten supply-chain control.
+    *   Corrected stale external app dependency entries by replacing `dotenv` with `python-dotenv`, removing the stdlib-only `logging` package, removing an unused `Flask` requirement from the databaseseeder utility, and adding `pytest-playwright` so the UI test dependency set matches the pytest fixture usage in the test suite.
+    *   (Ref: `application/single_app/requirements.txt`, `ui_tests/requirements.txt`, `deployers/bicep/requirements.txt`, `application/external_apps/databaseseeder/requirements.txt`, `application/external_apps/bulkloader/requirements.txt`)
+
 *   **Pillow PSD Upload Hardening**
     *   Updated the application to use `pillow==12.1.1`, moving the app off the vulnerable Pillow range for specially crafted PSD image parsing.
     *   Hardened admin logo and favicon uploads so Pillow now only opens the PNG and JPEG formats already allowed by the route, preventing disguised PSD content from being decoded during upload processing.

From 567e280ec73d281b14b3c6c677a1cc735b6beb5e Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 10:05:08 -0400
Subject: [PATCH 09/12] Update release_notes.md

---
 docs/explanation/release_notes.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/docs/explanation/release_notes.md b/docs/explanation/release_notes.md
index 7a5ee672..b5479b80 100644
--- a/docs/explanation/release_notes.md
+++ b/docs/explanation/release_notes.md
@@ -119,6 +119,15 @@ For feature-focused and fix-focused drill-downs by version, see [Features by Ver
     *   **End-to-End Auditability**: Users can verify exactly which aggregations, filters, or queries were run against their data, what parameters were used, and what raw results were returned — before the LLM summarized them into the final response.
     *   (Ref: `collect_tabular_sk_citations()`, `plugin_invocation_logger.py`)
 
+*   **Assistant Citation Artifact Storage for Large Tabular Payloads**
+    *   Moved large raw tabular and tool citation payloads off the main assistant message document and into linked child artifact records so tool-heavy answers stay compact in primary chat storage.
+    *   Added helper flows in `functions_message_artifacts.py` to keep a compact citation summary on the assistant message, externalize the full raw citation payload into `assistant_artifact` records with `assistant_artifact_chunk` support for larger payloads, and rehydrate those raw payloads later for exports or deeper inspection.
+    *   Assistant messages now keep compact summaries such as tool name, reduced arguments, counts, and a few sample rows while the heavy raw citation payload is referenced through `artifact_id` and `raw_payload_externalized=True`.
+    *   Updated chat persistence to store the linked artifact records during message save, excluded those artifact records from normal chat history and conversation views, and updated export flows to stitch the preserved raw payloads back together when needed.
+    *   This reduced primary assistant message size, lowered the risk of hitting Cosmos DB per-item limits on large tabular responses, reduced heavy citation data carried through normal chat reads, and preserved the full raw evidence for export and debugging.
+    *   Additional size reductions in the same phase compacted stored citation summaries, dropped noisy tabular citation arguments such as `user_id`, `conversation_id`, and `source`, and removed the duplicate `user_message` field from assistant message documents.
+    *   (Ref: `functions_message_artifacts.py`, `route_backend_chats.py`, `route_backend_conversations.py`, `route_frontend_conversations.py`, `route_backend_conversation_export.py`, `test_assistant_citation_artifact_storage.py`, `ASSISTANT_CITATION_ARTIFACT_STORAGE_FIX.md`)
+
 *   **SK Mini-Agent Performance Optimization**
     *   Reduced typical tabular analysis time from ~74 seconds to an estimated ~30-33 seconds (55-60% reduction) through three complementary optimizations.
     *   **DataFrame Caching**: Per-request in-memory cache eliminates redundant blob downloads. Previously, each of the ~8 tool calls in a typical analysis downloaded and parsed the same file independently. Now the file is downloaded once and subsequent calls read from cache. Cache is automatically scoped to the request (new plugin instance per analysis) and garbage-collected afterward.

From 7fed82b0b4e54643c1d39031762911a694d88be4 Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 10:07:51 -0400
Subject: [PATCH 10/12] Update release_notes.md

---
 docs/explanation/release_notes.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/docs/explanation/release_notes.md b/docs/explanation/release_notes.md
index b5479b80..690c6095 100644
--- a/docs/explanation/release_notes.md
+++ b/docs/explanation/release_notes.md
@@ -173,6 +173,15 @@ For feature-focused and fix-focused drill-downs by version, see [Features by Ver
     *   Added optional Azure Video Indexer deployment support with cloud-aware defaults, including the correct endpoint and ARM API version handling for Azure Commercial, Azure Government, and registered custom clouds.
     *   (Ref: `deployers/azure.yaml`, `deployers/azurecli/deploy-simplechat.ps1`, `deployers/bicep/main.bicep`, `deployers/bicep/modules/videoIndexer.bicep`, `deployers/terraform/main.tf`, `application/single_app/functions_settings.py`)
 
+*   **Idle Session Timeout Feature**
+    *   Added a new idle timer that automatically clears the user session after a configurable set time and redirects to the main chat login page.
+    *   Added a frontend idle warning modal that pops up after a configurable set time, but disappears if the user moves the mouse over the chat window or interacts with the app in any way.
+    *   Default values are used if the idle logout and warning values are not set. 
+    *   Idle logout and idle warning values are validated and auto-fixed as needed.
+    *   Added a new admin switch to enable or disable idle session timeout and warning behavior.
+    *   Timeout and warning inputs are grouped under a toggleable section in General > System Settings.
+    *   (Ref: `application/single_app/templates/admin_settings.html`, `application/single_app/static/js/admin/admin_settings.js`, `application/single_app/route_frontend_admin_settings.py`, `application/single_app/functions_settings.py`, `application/single_app/app.py`, `application/single_app/templates/base.html`, `application/single_app/static/js/idle-logout-warning.js`, `application/single_app/config.py`, `functional_tests/test_idle_logout_timeout.py`, `application/single_app/route_frontend_authentication.py`)
+
 #### User Interface Enhancements
 
 *   **Agent Responded Thought — Seconds & Total Duration**
@@ -227,6 +236,12 @@ For feature-focused and fix-focused drill-downs by version, see [Features by Ver
     *   Corrected stale external app dependency entries by replacing `dotenv` with `python-dotenv`, removing the stdlib-only `logging` package, removing an unused `Flask` requirement from the databaseseeder utility, and adding `pytest-playwright` so the UI test dependency set matches the pytest fixture usage in the test suite.
     *   (Ref: `application/single_app/requirements.txt`, `ui_tests/requirements.txt`, `deployers/bicep/requirements.txt`, `application/external_apps/databaseseeder/requirements.txt`, `application/external_apps/bulkloader/requirements.txt`)
 
+*   **Settings Default Merge Persistence Fix**
+    *   Fixed app settings merge detection in `get_settings()` where `deep_merge_dicts()` mutates the existing settings object in place, causing change detection to always evaluate as unchanged.
+    *   Updated `deep_merge_dicts()` to return a boolean `changed` flag and wired `get_settings()` to call `upsert_item()` when `settings_changed` is `True`, so missing default keys correctly trigger persistence back to Cosmos DB.
+    *   Added a functional regression test to validate the merge detection and persistence markers.
+    *   (Ref: `application/single_app/functions_settings.py`, `application/single_app/config.py`, `functional_tests/test_settings_deep_merge_persistence_fix.py`)
+    
 *   **Pillow PSD Upload Hardening**
     *   Updated the application to use `pillow==12.1.1`, moving the app off the vulnerable Pillow range for specially crafted PSD image parsing.
     *   Hardened admin logo and favicon uploads so Pillow now only opens the PNG and JPEG formats already allowed by the route, preventing disguised PSD content from being decoded during upload processing.

From 53e8213e5eb903b4121f23b69720dd508722ef3b Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 10:40:39 -0400
Subject: [PATCH 11/12] fix plugin id handling

---
 application/single_app/config.py              |   2 +-
 .../single_app/route_backend_plugins.py       |  62 ++--
 ...ER_PLUGIN_BULK_SAVE_ID_PRESERVATION_FIX.md |  51 +++
 ...t_user_plugin_bulk_save_id_preservation.py | 309 ++++++++++++++++++
 4 files changed, 394 insertions(+), 30 deletions(-)
 create mode 100644 docs/explanation/fixes/USER_PLUGIN_BULK_SAVE_ID_PRESERVATION_FIX.md
 create mode 100644 functional_tests/test_user_plugin_bulk_save_id_preservation.py

diff --git a/application/single_app/config.py b/application/single_app/config.py
index adb62878..cf8d2b2e 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.018"
+VERSION = "0.240.019"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/route_backend_plugins.py b/application/single_app/route_backend_plugins.py
index a9057dba..115bf282 100644
--- a/application/single_app/route_backend_plugins.py
+++ b/application/single_app/route_backend_plugins.py
@@ -336,59 +336,63 @@ def set_user_plugins():
     for plugin in plugins:
         if plugin.get('name', '').lower() in global_plugin_names:
             continue  # Skip global plugins
+        plugin_to_save = dict(plugin)
         # Remove is_global if present
-        if 'is_global' in plugin:
-            del plugin['is_global']
+        if 'is_global' in plugin_to_save:
+            del plugin_to_save['is_global']
         
         # Ensure required fields have default values
-        plugin.setdefault('name', '')
-        plugin.setdefault('displayName', plugin.get('name', ''))
-        plugin.setdefault('description', '')
-        plugin.setdefault('metadata', {})
-        plugin.setdefault('additionalFields', {})
+        plugin_to_save.setdefault('name', '')
+        plugin_to_save.setdefault('displayName', plugin_to_save.get('name', ''))
+        plugin_to_save.setdefault('description', '')
+        plugin_to_save.setdefault('metadata', {})
+        plugin_to_save.setdefault('additionalFields', {})
         
-        # Remove storage-managed fields that are not part of the plugin manifest schema.
+        # Remove storage-managed fields that are not part of the plugin manifest schema,
+        # but preserve the action ID so existing records can be updated in place.
         for field in PLUGIN_STORAGE_MANAGED_FIELDS:
-            plugin.pop(field, None)
+            if field == 'id':
+                continue
+            plugin_to_save.pop(field, None)
         
         # Handle endpoint based on plugin type
-        plugin_type = plugin.get('type', '')
+        plugin_type = plugin_to_save.get('type', '')
         if plugin_type in ['sql_schema', 'sql_query']:
             # SQL plugins don't use endpoints, but schema validation requires one
             # Use a placeholder that indicates it's a SQL plugin
-            plugin.setdefault('endpoint', f'sql://{plugin_type}')
+            plugin_to_save.setdefault('endpoint', f'sql://{plugin_type}')
         elif plugin_type == 'msgraph':
             # MS Graph plugin does not require an endpoint, but schema validation requires one
             #TODO: Update to support different clouds
-            plugin.setdefault('endpoint', 'https://graph.microsoft.com')
+            plugin_to_save.setdefault('endpoint', 'https://graph.microsoft.com')
         else:
             # For other plugin types, require a real endpoint
-            plugin.setdefault('endpoint', '')
+            plugin_to_save.setdefault('endpoint', '')
         
         # Ensure auth has default structure
-        if 'auth' not in plugin:
-            plugin['auth'] = {'type': 'identity'}
-        elif not isinstance(plugin['auth'], dict):
-            plugin['auth'] = {'type': 'identity'}
-        elif 'type' not in plugin['auth']:
-            plugin['auth']['type'] = 'identity'
+        if 'auth' not in plugin_to_save:
+            plugin_to_save['auth'] = {'type': 'identity'}
+        elif not isinstance(plugin_to_save['auth'], dict):
+            plugin_to_save['auth'] = {'type': 'identity'}
+        elif 'type' not in plugin_to_save['auth']:
+            plugin_to_save['auth']['type'] = 'identity'
         
         # Auto-fill type from metadata if missing or empty
-        if not plugin.get('type'):
-            if plugin.get('metadata', {}).get('type'):
-                plugin['type'] = plugin['metadata']['type']
+        if not plugin_to_save.get('type'):
+            if plugin_to_save.get('metadata', {}).get('type'):
+                plugin_to_save['type'] = plugin_to_save['metadata']['type']
             else:
-                plugin['type'] = 'unknown'  # Default type
+                plugin_to_save['type'] = 'unknown'  # Default type
         
-        debug_print(f"Plugin build: {_redact_plugin_for_logging(plugin)}")
-        validation_error = validate_plugin(plugin)
+        debug_print(f"Plugin build: {_redact_plugin_for_logging(plugin_to_save)}")
+        validation_error = validate_plugin(plugin_to_save)
         if validation_error:
             return jsonify({'error': f'Plugin validation failed: {validation_error}'}), 400
         
-        filtered_plugins.append(plugin)
-        new_plugin_names.add(plugin['name'])
-        if plugin.get('id'):
-            new_plugin_ids.add(plugin['id'])
+        filtered_plugins.append(plugin_to_save)
+        new_plugin_names.add(plugin_to_save['name'])
+        if plugin_to_save.get('id'):
+            new_plugin_ids.add(plugin_to_save['id'])
     
     # Save each plugin to the personal_actions container
     plugins_to_delete = []
diff --git a/docs/explanation/fixes/USER_PLUGIN_BULK_SAVE_ID_PRESERVATION_FIX.md b/docs/explanation/fixes/USER_PLUGIN_BULK_SAVE_ID_PRESERVATION_FIX.md
new file mode 100644
index 00000000..3ce7302e
--- /dev/null
+++ b/docs/explanation/fixes/USER_PLUGIN_BULK_SAVE_ID_PRESERVATION_FIX.md
@@ -0,0 +1,51 @@
+# USER_PLUGIN_BULK_SAVE_ID_PRESERVATION_FIX.md
+
+## User Plugin Bulk Save ID Preservation Fix (v0.240.019)
+
+Fixed/Implemented in version: **0.240.019**
+
+### Issue Description
+
+Bulk saves to `/api/user/plugins` could drop the persisted action `id` before the route finished
+its bookkeeping. When a user renamed an existing personal plugin from the workspace UI, the
+ request still included the existing `id`, but the route removed it before save and delete logic.
+
+### Root Cause Analysis
+
+`set_user_plugins()` stripped all storage-managed fields directly from the working plugin dict,
+including `id`. Later in the same request, the route relied on `plugin.get('id')` to populate
+`new_plugin_ids` and decide which existing personal actions should be retained. Because the
+ identifier had already been removed, rename flows looked like delete-and-recreate operations.
+
+### Technical Details
+
+Files modified:
+- `application/single_app/route_backend_plugins.py`
+- `application/single_app/config.py`
+- `functional_tests/test_user_plugin_bulk_save_id_preservation.py`
+
+Code changes summary:
+- Updated the user bulk-save route to work on a copy of each incoming plugin payload.
+- Continued stripping storage-managed audit fields before validation and persistence.
+- Preserved `id` so existing personal actions can be matched during rename flows.
+- Bumped the application version and added a route-level regression test.
+
+Testing approach:
+- Added `functional_tests/test_user_plugin_bulk_save_id_preservation.py` to load the route module
+  with isolated stubs and verify that rename payloads keep the original `id`, skip deletion, and
+  do not leak storage-managed audit fields into validation/save operations.
+
+Impact analysis:
+- Prevents renamed personal plugins from being deleted and recreated with new IDs.
+- Keeps route bookkeeping aligned with the persisted record identity sent by the client.
+- Maintains existing sanitization for storage-managed audit fields during bulk saves.
+
+### Validation
+
+Before:
+- The route removed `id` before validation and delete bookkeeping.
+- Renaming a personal plugin could generate a new action ID and delete the existing action.
+
+After:
+- The route preserves `id` while still stripping the other storage-managed fields.
+- Renamed personal plugins update in place and are no longer misidentified as deletions.
\ No newline at end of file
diff --git a/functional_tests/test_user_plugin_bulk_save_id_preservation.py b/functional_tests/test_user_plugin_bulk_save_id_preservation.py
new file mode 100644
index 00000000..36e89d51
--- /dev/null
+++ b/functional_tests/test_user_plugin_bulk_save_id_preservation.py
@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+# test_user_plugin_bulk_save_id_preservation.py
+"""
+Functional test for user plugin bulk-save ID preservation.
+Version: 0.240.019
+Implemented in: 0.240.019
+
+This test ensures bulk user plugin saves preserve existing action IDs during
+rename flows so persisted actions are updated in place instead of deleted and
+recreated with new IDs.
+"""
+
+import importlib
+import os
+import sys
+import types
+from copy import deepcopy
+
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(REPO_ROOT, 'application', 'single_app'))
+
+
+def _passthrough_decorator(*decorator_args, **decorator_kwargs):
+    """Return the wrapped function unchanged for route/auth decorator stubs."""
+    if decorator_args and callable(decorator_args[0]) and len(decorator_args) == 1 and not decorator_kwargs:
+        return decorator_args[0]
+
+    def decorator(func):
+        return func
+
+    return decorator
+
+
+class DummyBlueprint:
+    """Minimal Flask Blueprint stub used for importing route modules."""
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+    def route(self, *args, **kwargs):
+        return _passthrough_decorator
+
+
+def _restore_modules(original_modules):
+    for module_name, original_module in original_modules.items():
+        if original_module is None:
+            sys.modules.pop(module_name, None)
+        else:
+            sys.modules[module_name] = original_module
+
+
+def _load_route_module(state):
+    request_stub = types.SimpleNamespace(json=None)
+
+    flask_stub = types.ModuleType('flask')
+    flask_stub.Blueprint = DummyBlueprint
+    flask_stub.jsonify = lambda payload: payload
+    flask_stub.request = request_stub
+    flask_stub.current_app = types.SimpleNamespace(root_path=os.path.join(REPO_ROOT, 'application', 'single_app'))
+
+    plugin_loader_stub = types.ModuleType('semantic_kernel_plugins.plugin_loader')
+    plugin_loader_stub.get_all_plugin_metadata = lambda: []
+
+    plugin_health_checker_stub = types.ModuleType('semantic_kernel_plugins.plugin_health_checker')
+
+    class PluginHealthChecker:
+        @staticmethod
+        def validate_plugin_manifest(plugin, plugin_type):
+            return True, []
+
+    plugin_health_checker_stub.PluginHealthChecker = PluginHealthChecker
+    plugin_health_checker_stub.PluginErrorRecovery = object
+
+    base_plugin_stub = types.ModuleType('semantic_kernel_plugins.base_plugin')
+
+    class BasePlugin:
+        pass
+
+    base_plugin_stub.BasePlugin = BasePlugin
+
+    settings_stub = types.ModuleType('functions_settings')
+    settings_stub.get_settings = lambda: {}
+    settings_stub.is_tabular_processing_enabled = lambda: False
+    settings_stub.update_settings = lambda updates: True
+
+    auth_stub = types.ModuleType('functions_authentication')
+    auth_stub.login_required = _passthrough_decorator
+    auth_stub.user_required = _passthrough_decorator
+    auth_stub.admin_required = _passthrough_decorator
+    auth_stub.enabled_required = _passthrough_decorator
+    auth_stub.get_current_user_id = lambda: state['user_id']
+
+    appinsights_stub = types.ModuleType('functions_appinsights')
+    appinsights_stub.log_event = lambda *args, **kwargs: None
+
+    swagger_stub = types.ModuleType('swagger_wrapper')
+    swagger_stub.swagger_route = _passthrough_decorator
+    swagger_stub.get_auth_security = lambda: []
+
+    debug_stub = types.ModuleType('functions_debug')
+    debug_stub.debug_print = lambda *args, **kwargs: None
+
+    plugins_stub = types.ModuleType('functions_plugins')
+    plugins_stub.get_merged_plugin_settings = lambda *args, **kwargs: {}
+
+    global_actions_stub = types.ModuleType('functions_global_actions')
+    global_actions_stub.get_global_actions = lambda: []
+
+    personal_actions_stub = types.ModuleType('functions_personal_actions')
+
+    def get_personal_actions(user_id, return_type=None):
+        return [deepcopy(action) for action in state['current_actions']]
+
+    def save_personal_action(user_id, plugin):
+        plugin_to_save = deepcopy(plugin)
+        if not plugin_to_save.get('id'):
+            plugin_to_save['id'] = 'generated-new-id'
+        state['saved_plugins'].append({'user_id': user_id, 'plugin': plugin_to_save})
+        return plugin_to_save
+
+    def delete_personal_action(user_id, action_id):
+        state['deleted_actions'].append({'user_id': user_id, 'action_id': action_id})
+        return True
+
+    personal_actions_stub.get_personal_actions = get_personal_actions
+    personal_actions_stub.save_personal_action = save_personal_action
+    personal_actions_stub.delete_personal_action = delete_personal_action
+
+    group_stub = types.ModuleType('functions_group')
+    group_stub.require_active_group = lambda *args, **kwargs: None
+    group_stub.assert_group_role = lambda *args, **kwargs: None
+
+    group_actions_stub = types.ModuleType('functions_group_actions')
+    group_actions_stub.get_group_actions = lambda *args, **kwargs: []
+    group_actions_stub.get_group_action = lambda *args, **kwargs: None
+    group_actions_stub.save_group_action = lambda *args, **kwargs: None
+    group_actions_stub.delete_group_action = lambda *args, **kwargs: None
+    group_actions_stub.validate_group_action_payload = lambda *args, **kwargs: None
+
+    keyvault_stub = types.ModuleType('functions_keyvault')
+
+    class SecretReturnType:
+        NAME = 'name'
+        TRIGGER = 'trigger'
+
+    keyvault_stub.SecretReturnType = SecretReturnType
+    keyvault_stub.redact_plugin_secret_values = lambda plugin: plugin
+    keyvault_stub.retrieve_secret_from_key_vault_by_full_name = lambda *args, **kwargs: None
+    keyvault_stub.ui_trigger_word = 'Stored_In_KeyVault'
+    keyvault_stub.validate_secret_name_dynamic = lambda *args, **kwargs: True
+
+    validation_stub = types.ModuleType('json_schema_validation')
+    validation_stub.PLUGIN_STORAGE_MANAGED_FIELDS = {
+        'created_at',
+        'created_by',
+        'id',
+        'is_global',
+        'last_updated',
+        'modified_at',
+        'modified_by',
+        'updated_at',
+        'user_id',
+    }
+
+    def validate_plugin(plugin):
+        state['validation_inputs'].append(deepcopy(plugin))
+        return None
+
+    validation_stub.validate_plugin = validate_plugin
+
+    activity_stub = types.ModuleType('functions_activity_logging')
+    activity_stub.log_action_creation = lambda *args, **kwargs: None
+    activity_stub.log_action_update = lambda *args, **kwargs: None
+    activity_stub.log_action_deletion = lambda *args, **kwargs: None
+
+    original_modules = {}
+    module_stubs = {
+        'flask': flask_stub,
+        'semantic_kernel_plugins.plugin_loader': plugin_loader_stub,
+        'semantic_kernel_plugins.plugin_health_checker': plugin_health_checker_stub,
+        'semantic_kernel_plugins.base_plugin': base_plugin_stub,
+        'functions_settings': settings_stub,
+        'functions_authentication': auth_stub,
+        'functions_appinsights': appinsights_stub,
+        'swagger_wrapper': swagger_stub,
+        'functions_debug': debug_stub,
+        'functions_plugins': plugins_stub,
+        'functions_global_actions': global_actions_stub,
+        'functions_personal_actions': personal_actions_stub,
+        'functions_group': group_stub,
+        'functions_group_actions': group_actions_stub,
+        'functions_keyvault': keyvault_stub,
+        'json_schema_validation': validation_stub,
+        'functions_activity_logging': activity_stub,
+    }
+
+    for module_name, module_stub in module_stubs.items():
+        original_modules[module_name] = sys.modules.get(module_name)
+        sys.modules[module_name] = module_stub
+
+    original_modules['route_backend_plugins'] = sys.modules.get('route_backend_plugins')
+    sys.modules.pop('route_backend_plugins', None)
+
+    module = importlib.import_module('route_backend_plugins')
+    return module, request_stub, original_modules
+
+
+def test_bulk_save_preserves_existing_id_on_rename():
+    """Bulk saves should keep the original ID when a personal plugin is renamed."""
+    print('🔍 Testing user plugin bulk-save ID preservation on rename...')
+
+    state = {
+        'user_id': 'test-user-plugin-rename',
+        'current_actions': [
+            {
+                'id': 'existing-plugin-id',
+                'name': 'legacy_plugin_name',
+                'description': 'Original plugin description',
+            }
+        ],
+        'saved_plugins': [],
+        'deleted_actions': [],
+        'validation_inputs': [],
+    }
+
+    module = None
+    original_modules = {}
+
+    try:
+        module, request_stub, original_modules = _load_route_module(state)
+        request_stub.json = [
+            {
+                'id': 'existing-plugin-id',
+                'name': 'renamed_plugin',
+                'displayName': 'Renamed Plugin',
+                'type': 'sql_schema',
+                'description': 'Updated plugin description',
+                'endpoint': 'sql://sql_schema',
+                'auth': {'type': 'identity'},
+                'metadata': {},
+                'additionalFields': {},
+                'created_by': 'stale-user',
+                'modified_at': '2026-04-02T12:00:00Z',
+                'user_id': 'stale-user',
+            }
+        ]
+
+        response = module.set_user_plugins()
+        if response != {'success': True}:
+            print(f'❌ Unexpected route response: {response}')
+            return False
+
+        if len(state['saved_plugins']) != 1:
+            print(f"❌ Expected 1 saved plugin, found {len(state['saved_plugins'])}")
+            return False
+
+        saved_plugin = state['saved_plugins'][0]['plugin']
+        if saved_plugin.get('id') != 'existing-plugin-id':
+            print(f"❌ Expected preserved ID 'existing-plugin-id', got {saved_plugin.get('id')}")
+            return False
+
+        if saved_plugin.get('name') != 'renamed_plugin':
+            print(f"❌ Expected renamed plugin name, got {saved_plugin.get('name')}")
+            return False
+
+        if state['deleted_actions']:
+            print(f"❌ Existing action should not be deleted during rename: {state['deleted_actions']}")
+            return False
+
+        validation_input = state['validation_inputs'][0]
+        if validation_input.get('id') != 'existing-plugin-id':
+            print(f"❌ Validation payload lost the existing ID: {validation_input}")
+            return False
+
+        leaked_fields = [field for field in ('created_by', 'modified_at', 'user_id') if field in validation_input or field in saved_plugin]
+        if leaked_fields:
+            print(f'❌ Storage-managed fields leaked through the route sanitization: {leaked_fields}')
+            return False
+
+        print('✅ Existing plugin ID was preserved during rename')
+        print('✅ Existing action was not deleted during rename')
+        print('✅ Storage-managed audit fields were stripped before validation/save')
+        return True
+    except Exception as exc:
+        print(f'❌ User plugin bulk-save ID preservation test failed: {exc}')
+        import traceback
+        traceback.print_exc()
+        return False
+    finally:
+        _restore_modules(original_modules)
+
+
+if __name__ == '__main__':
+    print('🧪 Running user plugin bulk-save ID preservation tests...\n')
+
+    tests = [
+        test_bulk_save_preserves_existing_id_on_rename,
+    ]
+    results = []
+
+    for test in tests:
+        print(f'\n🧪 Running {test.__name__}...')
+        results.append(test())
+
+    success = all(results)
+    print(f'\n📊 Results: {sum(results)}/{len(results)} tests passed')
+    sys.exit(0 if success else 1)
\ No newline at end of file

From d06ab29cdce6eb9b53f845cefd1121d56a3952ed Mon Sep 17 00:00:00 2001
From: Paul Lizer <paullizer@microsoft.com>
Date: Thu, 2 Apr 2026 10:54:05 -0400
Subject: [PATCH 12/12] fix json parsing

---
 application/single_app/config.py              |   2 +-
 application/single_app/route_backend_chats.py |   2 +-
 .../single_app/templates/admin_settings.html  |  68 +++++----
 .../templates/group_workspaces.html           |   6 +-
 .../templates/public_workspaces.html          |   2 +-
 .../single_app/templates/workspace.html       |   6 +-
 .../SINGLE_APP_TEMPLATE_JSON_BOOTSTRAP_FIX.md |  50 +++++++
 ...ngle_app_template_json_bootstrap_safety.py | 113 +++++++++++++++
 ...ngle_app_template_json_bootstrap_render.py | 134 ++++++++++++++++++
 9 files changed, 345 insertions(+), 38 deletions(-)
 create mode 100644 docs/explanation/fixes/SINGLE_APP_TEMPLATE_JSON_BOOTSTRAP_FIX.md
 create mode 100644 functional_tests/test_single_app_template_json_bootstrap_safety.py
 create mode 100644 ui_tests/test_single_app_template_json_bootstrap_render.py

diff --git a/application/single_app/config.py b/application/single_app/config.py
index cf8d2b2e..dd712ec8 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -94,7 +94,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.240.019"
+VERSION = "0.240.020"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 
diff --git a/application/single_app/route_backend_chats.py b/application/single_app/route_backend_chats.py
index f7052d3d..92ff4dd3 100644
--- a/application/single_app/route_backend_chats.py
+++ b/application/single_app/route_backend_chats.py
@@ -2094,7 +2094,7 @@ def build_system_prompt(force_tool_use=False, tool_error_messages=None, executio
                 "19. For peak, busiest, highest, or lowest questions, use grouped functions and inspect the highest_group, highest_value, lowest_group, and lowest_value summary fields.\n"
                 "20. Return only computed findings and name the strongest drivers clearly.\n"
                 "21. Do not mention hypothetical follow-up analyses, parser errors, or failed attempts unless the user explicitly asked about failures and you have actual tool error output to report.\n"
-                "21. When using query_tabular_data, use simple DataFrame.query() syntax with backticked column names for columns containing spaces. Avoid method calls such as .str.lower(), .astype(...), or other Python expressions that DataFrame.query() may reject."
+                "22. When using query_tabular_data, use simple DataFrame.query() syntax with backticked column names for columns containing spaces. Avoid method calls such as .str.lower(), .astype(...), or other Python expressions that DataFrame.query() may reject."
             )
 
         baseline_invocations = plugin_logger.get_invocations_for_conversation(
diff --git a/application/single_app/templates/admin_settings.html b/application/single_app/templates/admin_settings.html
index cf0f35d1..05f09ea6 100644
--- a/application/single_app/templates/admin_settings.html
+++ b/application/single_app/templates/admin_settings.html
@@ -5566,31 +5566,50 @@ <h5 class="modal-title" id="userAgreementPreviewModalLabel">
 
 <script>
     // Prepopulate model arrays and classification data from server
-    window.gptSelected = JSON.parse('{{ settings.gpt_model.selected|tojson()|safe }}' || '[]');
-    window.gptAll      = JSON.parse('{{ settings.gpt_model.all|tojson()|safe }}' || '[]');
+    window.gptSelected = {{ settings.gpt_model.selected|default([], true)|tojson|safe }};
+    window.gptAll      = {{ settings.gpt_model.all|default([], true)|tojson|safe }};
 
-    window.embeddingSelected = JSON.parse('{{ settings.embedding_model.selected|tojson()|safe }}' || '[]');
-    window.embeddingAll      = JSON.parse('{{ settings.embedding_model.all|tojson()|safe }}' || '[]');
+    window.embeddingSelected = {{ settings.embedding_model.selected|default([], true)|tojson|safe }};
+    window.embeddingAll      = {{ settings.embedding_model.all|default([], true)|tojson|safe }};
 
-    window.imageSelected = JSON.parse('{{ settings.image_gen_model.selected|tojson()|safe }}' || '[]');
-    window.imageAll      = JSON.parse('{{ settings.image_gen_model.all|tojson()|safe }}' || '[]');
+    window.imageSelected = {{ settings.image_gen_model.selected|default([], true)|tojson|safe }};
+    window.imageAll      = {{ settings.image_gen_model.all|default([], true)|tojson|safe }};
 
     window.enableMultiModelEndpoints = {{ 'true' if settings.enable_multi_model_endpoints else 'false' }};
-    window.modelEndpoints = JSON.parse('{{ settings.model_endpoints|tojson()|safe }}' || '[]');
-    window.defaultModelSelection = JSON.parse('{{ settings.default_model_selection|tojson()|safe }}' || '{}');
-    window.multiEndpointMigrationNotice = JSON.parse('{{ settings.multi_endpoint_migration_notice|tojson()|safe }}' || '{}');
+    window.modelEndpoints = {{ settings.model_endpoints|default([], true)|tojson|safe }};
+    window.defaultModelSelection = {{ settings.default_model_selection|default({}, true)|tojson|safe }};
+    window.multiEndpointMigrationNotice = {{ settings.multi_endpoint_migration_notice|default({}, true)|tojson|safe }};
 
-    // *** NEW: Classification Data ***
-    try {
-        let categoriesStr = '{{ settings.document_classification_categories|tojson(indent=None)|safe }}';
-        if (!categoriesStr || categoriesStr.trim() === '') {
-            categoriesStr = '[]';
-        }
-        window.classificationCategories = JSON.parse(categoriesStr);
-    } catch (e) {
-        console.error("Error parsing classification categories:", e);
-        window.classificationCategories = [];
+    if (!Array.isArray(window.gptSelected)) {
+        window.gptSelected = [];
+    }
+    if (!Array.isArray(window.gptAll)) {
+        window.gptAll = [];
+    }
+    if (!Array.isArray(window.embeddingSelected)) {
+        window.embeddingSelected = [];
+    }
+    if (!Array.isArray(window.embeddingAll)) {
+        window.embeddingAll = [];
+    }
+    if (!Array.isArray(window.imageSelected)) {
+        window.imageSelected = [];
+    }
+    if (!Array.isArray(window.imageAll)) {
+        window.imageAll = [];
     }
+    if (!Array.isArray(window.modelEndpoints)) {
+        window.modelEndpoints = [];
+    }
+    if (!window.defaultModelSelection || typeof window.defaultModelSelection !== "object" || Array.isArray(window.defaultModelSelection)) {
+        window.defaultModelSelection = {};
+    }
+    if (!window.multiEndpointMigrationNotice || typeof window.multiEndpointMigrationNotice !== "object" || Array.isArray(window.multiEndpointMigrationNotice)) {
+        window.multiEndpointMigrationNotice = {};
+    }
+
+    // *** NEW: Classification Data ***
+    window.classificationCategories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};
     // Ensure it's always an array
     if (!Array.isArray(window.classificationCategories)) {
         window.classificationCategories = [];
@@ -5598,16 +5617,7 @@ <h5 class="modal-title" id="userAgreementPreviewModalLabel">
     window.enableDocumentClassification = "{{ enable_document_classification }}";
 
     // *** NEW: External Links Data ***
-    try {
-        let externalLinksStr = '{{ settings.external_links|tojson(indent=None)|safe }}';
-        if (!externalLinksStr || externalLinksStr.trim() === '') {
-            externalLinksStr = '[]';
-        }
-        window.externalLinks = JSON.parse(externalLinksStr);
-    } catch (e) {
-        console.error("Error parsing external links:", e);
-        window.externalLinks = [];
-    }
+    window.externalLinks = {{ settings.external_links|default([], true)|tojson(indent=None)|safe }};
     // Ensure it's always an array
     if (!Array.isArray(window.externalLinks)) {
         window.externalLinks = [];
diff --git a/application/single_app/templates/group_workspaces.html b/application/single_app/templates/group_workspaces.html
index ab0a5743..ea22c764 100644
--- a/application/single_app/templates/group_workspaces.html
+++ b/application/single_app/templates/group_workspaces.html
@@ -1475,8 +1475,8 @@ <h5 class="modal-title" id="groupTagSelectionModalLabel">Select Tags</h5>
 <script>
     window.enableMultiModelEndpoints = {{ 'true' if settings.enable_multi_model_endpoints else 'false' }};
     window.modelEndpointScope = 'group';
-    window.workspaceModelEndpoints = JSON.parse('{{ group_model_endpoints|default([])|tojson|safe }}' || '[]');
-    window.globalModelEndpoints = JSON.parse('{{ global_model_endpoints|default([])|tojson|safe }}' || '[]');
+  window.workspaceModelEndpoints = {{ group_model_endpoints|default([], true)|tojson|safe }};
+  window.globalModelEndpoints = {{ global_model_endpoints|default([], true)|tojson|safe }};
 </script>
 {% if settings.enable_semantic_kernel and settings.allow_group_custom_endpoints and settings.enable_multi_model_endpoints %}
 <script type="module" src="{{ url_for('static', filename='js/workspace/workspace_model_endpoints.js') }}"></script>
@@ -1484,7 +1484,7 @@ <h5 class="modal-title" id="groupTagSelectionModalLabel">Select Tags</h5>
 
 <!-- Pass backend flags to JS -->
 <script>
-  window.classification_categories = JSON.parse('{{ settings.document_classification_categories|tojson(indent=None)|safe }}' || '[]');
+  window.classification_categories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};
     if (!Array.isArray(window.classification_categories)) {
         window.classification_categories = [];
     }
diff --git a/application/single_app/templates/public_workspaces.html b/application/single_app/templates/public_workspaces.html
index b320bbc0..2d7b446b 100644
--- a/application/single_app/templates/public_workspaces.html
+++ b/application/single_app/templates/public_workspaces.html
@@ -666,7 +666,7 @@ <h5 class="modal-title" id="publicTagSelectionModalLabel">Select Tags</h5>
 <script>
   // Pass settings to JavaScript
   window.max_file_size_mb = {{ settings.max_file_size_mb | default(16) }};
-  window.classification_categories = JSON.parse('{{ settings.document_classification_categories|tojson(indent=None)|safe }}' || '[]');
+  window.classification_categories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};
   if (!Array.isArray(window.classification_categories)) {
     window.classification_categories = [];
   }
diff --git a/application/single_app/templates/workspace.html b/application/single_app/templates/workspace.html
index c216901f..5adcf57f 100644
--- a/application/single_app/templates/workspace.html
+++ b/application/single_app/templates/workspace.html
@@ -1553,8 +1553,8 @@ <h5 class="modal-title" id="approveSharedModalLabel">Approve Shared Document</h5
   <script>
     window.enableMultiModelEndpoints = {{ 'true' if settings.enable_multi_model_endpoints else 'false' }};
     window.modelEndpointScope = 'user';
-    window.workspaceModelEndpoints = JSON.parse('{{ personal_model_endpoints|default([])|tojson|safe }}' || '[]');
-    window.globalModelEndpoints = JSON.parse('{{ global_model_endpoints|default([])|tojson|safe }}' || '[]');
+      window.workspaceModelEndpoints = {{ personal_model_endpoints|default([], true)|tojson|safe }};
+      window.globalModelEndpoints = {{ global_model_endpoints|default([], true)|tojson|safe }};
   </script>
   {% if settings.per_user_semantic_kernel and settings.enable_semantic_kernel and settings.allow_user_custom_endpoints and settings.enable_multi_model_endpoints %}
   <script type="module" src="{{ url_for('static', filename='js/workspace/workspace_model_endpoints.js') }}"></script>
@@ -1565,7 +1565,7 @@ <h5 class="modal-title" id="approveSharedModalLabel">Approve Shared Document</h5
 
   <script>
     // Pass settings/flags needed by JS
-    window.classification_categories = JSON.parse('{{ settings.document_classification_categories|tojson(indent=None)|safe }}' || '[]');
+    window.classification_categories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};
     if (!Array.isArray(window.classification_categories)) {
         window.classification_categories = [];
     }
diff --git a/docs/explanation/fixes/SINGLE_APP_TEMPLATE_JSON_BOOTSTRAP_FIX.md b/docs/explanation/fixes/SINGLE_APP_TEMPLATE_JSON_BOOTSTRAP_FIX.md
new file mode 100644
index 00000000..02baafc4
--- /dev/null
+++ b/docs/explanation/fixes/SINGLE_APP_TEMPLATE_JSON_BOOTSTRAP_FIX.md
@@ -0,0 +1,50 @@
+# Single App Template JSON Bootstrap Fix
+
+Fixed/Implemented in version: **0.240.020**
+
+## Issue Description
+
+Several `single_app` templates were still bootstrapping server-side JSON with patterns such as `JSON.parse('{{ value|tojson }}')`. That left workspace and admin pages vulnerable to the same control-character and quoting failures already fixed in the chat template.
+
+## Root Cause Analysis
+
+- Jinja `tojson` output was being inserted into JavaScript string literals instead of being assigned directly as JavaScript literals.
+- JavaScript string parsing can consume escape sequences before `JSON.parse(...)` runs, which turns otherwise valid JSON into invalid runtime input when values contain newlines, quotes, or other escaped control characters.
+- The brittle pattern had spread across personal workspace, group workspace, public workspace, and admin settings bootstraps.
+
+## Technical Details
+
+### Files Modified
+
+- `application/single_app/templates/workspace.html`
+- `application/single_app/templates/group_workspaces.html`
+- `application/single_app/templates/public_workspaces.html`
+- `application/single_app/templates/admin_settings.html`
+- `application/single_app/config.py`
+- `functional_tests/test_single_app_template_json_bootstrap_safety.py`
+- `ui_tests/test_single_app_template_json_bootstrap_render.py`
+
+### Code Changes Summary
+
+- Replaced string-wrapped `JSON.parse(...)` bootstraps with direct `tojson` assignments in the affected templates.
+- Added `default([], true)` and `default({}, true)` where appropriate so array and object bootstraps stay well-typed when backend values are missing.
+- Kept or added lightweight runtime guards for arrays and objects in admin settings where downstream code already expects normalized shapes.
+- Added a functional regression test that scans the affected templates for safe and unsafe bootstrap snippets.
+- Added a Playwright smoke test that watches for syntax and JSON bootstrap errors while loading the affected pages.
+
+### Testing Approach
+
+- Functional regression: `functional_tests/test_single_app_template_json_bootstrap_safety.py`
+- UI regression: `ui_tests/test_single_app_template_json_bootstrap_render.py`
+
+## Validation
+
+### Before
+
+- Workspace and admin page bootstraps could fail in the browser when serialized values contained escaped control characters or quoting edge cases.
+
+### After
+
+- The affected templates now emit direct JavaScript literals from Jinja `tojson` output.
+- Escaped values remain encoded within the serialized payload instead of being reinterpreted by an intermediate JavaScript string literal.
+- The added regression tests help prevent `JSON.parse('{{ ...|tojson ... }}')` from being reintroduced in these templates.
\ No newline at end of file
diff --git a/functional_tests/test_single_app_template_json_bootstrap_safety.py b/functional_tests/test_single_app_template_json_bootstrap_safety.py
new file mode 100644
index 00000000..ebc78299
--- /dev/null
+++ b/functional_tests/test_single_app_template_json_bootstrap_safety.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# test_single_app_template_json_bootstrap_safety.py
+"""
+Functional test for single_app template JSON bootstrap safety.
+Version: 0.240.020
+Implemented in: 0.240.020
+
+This test ensures the workspace and admin templates emit bootstrapped JSON as
+direct JavaScript literals rather than wrapping Jinja JSON output in
+JSON.parse string literals that can break when payload values contain control
+characters or quotes.
+"""
+
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+CONFIG_FILE = REPO_ROOT / "application" / "single_app" / "config.py"
+
+TEMPLATE_CASES = {
+    "workspace.html": {
+        "path": REPO_ROOT / "application" / "single_app" / "templates" / "workspace.html",
+        "safe": [
+            "window.workspaceModelEndpoints = {{ personal_model_endpoints|default([], true)|tojson|safe }};",
+            "window.globalModelEndpoints = {{ global_model_endpoints|default([], true)|tojson|safe }};",
+            "window.classification_categories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};",
+        ],
+        "unsafe": [
+            "window.workspaceModelEndpoints = JSON.parse('{{ personal_model_endpoints|default([])|tojson|safe }}' || '[]');",
+            "window.globalModelEndpoints = JSON.parse('{{ global_model_endpoints|default([])|tojson|safe }}' || '[]');",
+            "window.classification_categories = JSON.parse('{{ settings.document_classification_categories|tojson(indent=None)|safe }}' || '[]');",
+        ],
+    },
+    "group_workspaces.html": {
+        "path": REPO_ROOT / "application" / "single_app" / "templates" / "group_workspaces.html",
+        "safe": [
+            "window.workspaceModelEndpoints = {{ group_model_endpoints|default([], true)|tojson|safe }};",
+            "window.globalModelEndpoints = {{ global_model_endpoints|default([], true)|tojson|safe }};",
+            "window.classification_categories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};",
+        ],
+        "unsafe": [
+            "window.workspaceModelEndpoints = JSON.parse('{{ group_model_endpoints|default([])|tojson|safe }}' || '[]');",
+            "window.globalModelEndpoints = JSON.parse('{{ global_model_endpoints|default([])|tojson|safe }}' || '[]');",
+            "window.classification_categories = JSON.parse('{{ settings.document_classification_categories|tojson(indent=None)|safe }}' || '[]');",
+        ],
+    },
+    "public_workspaces.html": {
+        "path": REPO_ROOT / "application" / "single_app" / "templates" / "public_workspaces.html",
+        "safe": [
+            "window.classification_categories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};",
+        ],
+        "unsafe": [
+            "window.classification_categories = JSON.parse('{{ settings.document_classification_categories|tojson(indent=None)|safe }}' || '[]');",
+        ],
+    },
+    "admin_settings.html": {
+        "path": REPO_ROOT / "application" / "single_app" / "templates" / "admin_settings.html",
+        "safe": [
+            "window.gptSelected = {{ settings.gpt_model.selected|default([], true)|tojson|safe }};",
+            "window.gptAll      = {{ settings.gpt_model.all|default([], true)|tojson|safe }};",
+            "window.embeddingSelected = {{ settings.embedding_model.selected|default([], true)|tojson|safe }};",
+            "window.embeddingAll      = {{ settings.embedding_model.all|default([], true)|tojson|safe }};",
+            "window.imageSelected = {{ settings.image_gen_model.selected|default([], true)|tojson|safe }};",
+            "window.imageAll      = {{ settings.image_gen_model.all|default([], true)|tojson|safe }};",
+            "window.modelEndpoints = {{ settings.model_endpoints|default([], true)|tojson|safe }};",
+            "window.defaultModelSelection = {{ settings.default_model_selection|default({}, true)|tojson|safe }};",
+            "window.multiEndpointMigrationNotice = {{ settings.multi_endpoint_migration_notice|default({}, true)|tojson|safe }};",
+            "window.classificationCategories = {{ settings.document_classification_categories|default([], true)|tojson(indent=None)|safe }};",
+            "window.externalLinks = {{ settings.external_links|default([], true)|tojson(indent=None)|safe }};",
+        ],
+        "unsafe": [
+            "window.gptSelected = JSON.parse('{{ settings.gpt_model.selected|tojson()|safe }}' || '[]');",
+            "window.gptAll      = JSON.parse('{{ settings.gpt_model.all|tojson()|safe }}' || '[]');",
+            "window.embeddingSelected = JSON.parse('{{ settings.embedding_model.selected|tojson()|safe }}' || '[]');",
+            "window.embeddingAll      = JSON.parse('{{ settings.embedding_model.all|tojson()|safe }}' || '[]');",
+            "window.imageSelected = JSON.parse('{{ settings.image_gen_model.selected|tojson()|safe }}' || '[]');",
+            "window.imageAll      = JSON.parse('{{ settings.image_gen_model.all|tojson()|safe }}' || '[]');",
+            "window.modelEndpoints = JSON.parse('{{ settings.model_endpoints|tojson()|safe }}' || '[]');",
+            "window.defaultModelSelection = JSON.parse('{{ settings.default_model_selection|tojson()|safe }}' || '{}');",
+            "window.multiEndpointMigrationNotice = JSON.parse('{{ settings.multi_endpoint_migration_notice|tojson()|safe }}' || '{}');",
+            "let categoriesStr = '{{ settings.document_classification_categories|tojson(indent=None)|safe }}';",
+            "window.classificationCategories = JSON.parse(categoriesStr);",
+            "let externalLinksStr = '{{ settings.external_links|tojson(indent=None)|safe }}';",
+            "window.externalLinks = JSON.parse(externalLinksStr);",
+        ],
+    },
+}
+
+
+def test_single_app_templates_bootstrap_json_with_direct_literals():
+    """Verify single_app templates bootstrap JSON with direct Jinja literals."""
+    config_content = CONFIG_FILE.read_text(encoding="utf-8")
+
+    assert 'VERSION = "0.240.020"' in config_content, "Expected config.py version 0.240.020"
+
+    failures = []
+    for template_name, case in TEMPLATE_CASES.items():
+        content = case["path"].read_text(encoding="utf-8")
+
+        missing_safe = [snippet for snippet in case["safe"] if snippet not in content]
+        if missing_safe:
+            failures.append(f"{template_name} missing safe snippets: {missing_safe}")
+
+        present_unsafe = [snippet for snippet in case["unsafe"] if snippet in content]
+        if present_unsafe:
+            failures.append(f"{template_name} still contains unsafe snippets: {present_unsafe}")
+
+    assert not failures, " ; ".join(failures)
+
+
+if __name__ == "__main__":
+    test_single_app_templates_bootstrap_json_with_direct_literals()
+    print("✅ single_app template JSON bootstrap safety verified.")
\ No newline at end of file
diff --git a/ui_tests/test_single_app_template_json_bootstrap_render.py b/ui_tests/test_single_app_template_json_bootstrap_render.py
new file mode 100644
index 00000000..7eef6a72
--- /dev/null
+++ b/ui_tests/test_single_app_template_json_bootstrap_render.py
@@ -0,0 +1,134 @@
+# test_single_app_template_json_bootstrap_render.py
+"""
+UI test for single_app template JSON bootstrap rendering.
+Version: 0.240.020
+Implemented in: 0.240.020
+
+This test ensures the affected single_app pages load without browser-side
+syntax errors or JSON bootstrap failures after direct `tojson` normalization.
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+
+BASE_URL = os.getenv("SIMPLECHAT_UI_BASE_URL", "").rstrip("/")
+STORAGE_STATE = os.getenv("SIMPLECHAT_UI_STORAGE_STATE", "")
+ADMIN_STORAGE_STATE = os.getenv("SIMPLECHAT_UI_ADMIN_STORAGE_STATE", "")
+
+SKIP_RESPONSE_CODES = {401, 403, 404}
+BOOTSTRAP_ERROR_TERMS = (
+    "SyntaxError",
+    "Bad control character",
+    "JSON.parse",
+    "Unexpected token",
+)
+
+
+def _require_base_url():
+    if not BASE_URL:
+        pytest.skip("Set SIMPLECHAT_UI_BASE_URL to run this UI test.")
+
+
+def _require_storage_state(storage_state, env_name):
+    if not storage_state or not Path(storage_state).exists():
+        pytest.skip(f"Set {env_name} to a valid authenticated Playwright storage state file.")
+
+
+def _assert_no_bootstrap_errors(page_errors, console_errors, page_path):
+    relevant_page_errors = [
+        message for message in page_errors if any(term in message for term in BOOTSTRAP_ERROR_TERMS)
+    ]
+    relevant_console_errors = [
+        message for message in console_errors if any(term in message for term in BOOTSTRAP_ERROR_TERMS)
+    ]
+
+    assert not relevant_page_errors, (
+        f"Expected {page_path} to avoid bootstrap page errors. Observed: {relevant_page_errors}"
+    )
+    assert not relevant_console_errors, (
+        f"Expected {page_path} to avoid bootstrap console errors. Observed: {relevant_console_errors}"
+    )
+
+
+def _load_and_check_page(context, page_path, ready_selector):
+    page = context.new_page()
+    page_errors = []
+    console_errors = []
+
+    def track_page_error(error):
+        page_errors.append(str(error))
+
+    def track_console(message):
+        if message.type == "error":
+            console_errors.append(message.text)
+
+    page.on("pageerror", track_page_error)
+    page.on("console", track_console)
+
+    response = page.goto(f"{BASE_URL}{page_path}", wait_until="domcontentloaded")
+    assert response is not None, f"Expected a navigation response when loading {page_path}."
+
+    if response.status in SKIP_RESPONSE_CODES:
+        page.close()
+        return False
+
+    assert response.ok, f"Expected {page_path} to load successfully, got HTTP {response.status}."
+    expect(page.locator(ready_selector)).to_be_visible()
+    page.wait_for_load_state("networkidle")
+    _assert_no_bootstrap_errors(page_errors, console_errors, page_path)
+    page.close()
+    return True
+
+
+@pytest.mark.ui
+def test_workspace_family_pages_bootstrap_cleanly(playwright):
+    """Validate workspace-family pages avoid JSON bootstrap errors."""
+    _require_base_url()
+    _require_storage_state(STORAGE_STATE, "SIMPLECHAT_UI_STORAGE_STATE")
+
+    browser = playwright.chromium.launch()
+    context = browser.new_context(
+        storage_state=STORAGE_STATE,
+        viewport={"width": 1440, "height": 900},
+    )
+
+    checked_pages = 0
+    try:
+        for page_path, ready_selector in [
+            ("/workspace", "#documents-tab"),
+            ("/group_workspaces", "#groupWorkspaceTabContent"),
+            ("/public_workspaces", "#publicWorkspaceTabContent"),
+        ]:
+            if _load_and_check_page(context, page_path, ready_selector):
+                checked_pages += 1
+
+        if checked_pages == 0:
+            pytest.skip("No workspace-family pages were available in this environment.")
+    finally:
+        context.close()
+        browser.close()
+
+
+@pytest.mark.ui
+def test_admin_settings_page_bootstrap_cleanly(playwright):
+    """Validate admin settings avoids JSON bootstrap errors for admin users."""
+    _require_base_url()
+    _require_storage_state(ADMIN_STORAGE_STATE, "SIMPLECHAT_UI_ADMIN_STORAGE_STATE")
+
+    browser = playwright.chromium.launch()
+    context = browser.new_context(
+        storage_state=ADMIN_STORAGE_STATE,
+        viewport={"width": 1440, "height": 900},
+    )
+
+    try:
+        loaded = _load_and_check_page(context, "/admin/settings", "#adminSettingsTabContent")
+        if not loaded:
+            pytest.skip("Admin settings page was not available for the configured admin session.")
+    finally:
+        context.close()
+        browser.close()
\ No newline at end of file