diff --git a/PanTS-Demo/src/components/AIAssistant/AISidebar.css b/PanTS-Demo/src/components/AIAssistant/AISidebar.css
index 2b1ea4a..5d006d4 100644
--- a/PanTS-Demo/src/components/AIAssistant/AISidebar.css
+++ b/PanTS-Demo/src/components/AIAssistant/AISidebar.css
@@ -8,7 +8,8 @@
   height: 100dvh;
   overflow: hidden;
   color: var(--vp-text, rgba(255, 255, 255, 0.92));
-  background: rgba(14, 15, 18, 0.86);
+  /* Match the top toolbar's "clear black" (.vp-topbar background) exactly. */
+  background: rgba(14, 15, 18, 0.92);
   border-left: 1px solid var(--vp-border, rgba(255, 255, 255, 0.09));
   box-shadow: 0 24px 60px -20px rgba(0, 0, 0, 0.8);
   backdrop-filter: blur(18px) saturate(140%);
@@ -199,59 +200,19 @@
   }
 }
 
-.ai-sidebar__suggestions {
-  display: flex;
-  gap: 7px;
-  overflow-x: auto;
-  padding: 0 16px 10px;
-  scrollbar-width: none;
-}
-
-.ai-sidebar__suggestions::-webkit-scrollbar {
-  display: none;
-}
-
-.ai-suggestion {
-  flex: 0 0 auto;
-  max-width: 245px;
-  overflow: hidden;
-  padding: 6px 9px;
-  border: 1px solid var(--vp-border, rgba(255, 255, 255, 0.09));
-  border-radius: 999px;
-  background: transparent;
-  color: var(--vp-text-faint, rgba(255, 255, 255, 0.36));
-  cursor: pointer;
-  font: inherit;
-  font-size: 11px;
-  line-height: 1.25;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  transition: color 140ms ease, background 140ms ease, border-color 140ms ease;
-}
-
-.ai-suggestion:hover {
-  color: var(--vp-text-dim, rgba(255, 255, 255, 0.5));
-  background: var(--vp-panel, rgba(255, 255, 255, 0.045));
-  border-color: var(--vp-border-strong, rgba(255, 255, 255, 0.16));
-}
-
 .ai-sidebar__composer-wrap {
   flex: 0 0 auto;
   padding: 0 14px max(14px, env(safe-area-inset-bottom));
 }
 
+/* A distinct, slightly darker box than the panel so the typing area is easy
+   to see, with a visible (but not flashy) outline. No bright focus highlight. */
 .ai-composer {
   overflow: visible;
-  border: 1px solid var(--vp-border, rgba(255, 255, 255, 0.09));
+  border: 1px solid rgba(255, 255, 255, 0.16);
   border-radius: 16px;
-  background: rgba(255, 255, 255, 0.048);
-  box-shadow: 0 12px 28px rgba(0, 0, 0, 0.2);
-  transition: border-color 140ms ease, background 140ms ease;
-}
-
-.ai-composer:focus-within {
-  border-color: var(--vp-border-strong, rgba(255, 255, 255, 0.16));
-  background: rgba(255, 255, 255, 0.058);
+  background: rgba(0, 0, 0, 0.32);
+  box-shadow: none;
 }
 
 .ai-composer__textarea {
@@ -292,7 +253,7 @@
 .ai-model-picker {
   position: relative;
   min-width: 0;
-  max-width: calc(100% - 45px);
+  max-width: 100%;
 }
 
 .ai-model-picker__button {
@@ -379,6 +340,13 @@
   -webkit-backdrop-filter: blur(18px) saturate(130%);
 }
 
+/* Anchored to the picker's right edge so it opens leftward and stays inside
+   the sidebar when the model picker sits next to Send. */
+.ai-model-menu--right {
+  left: auto;
+  right: 0;
+}
+
 .ai-model-menu__heading {
   padding: 6px 8px 7px;
   color: rgba(255, 255, 255, 0.43);
@@ -395,7 +363,7 @@
   justify-content: space-between;
   gap: 14px;
   width: 100%;
-  min-height: 48px;
+  min-height: 34px;
   padding: 8px 9px;
   border: 0;
   border-radius: 8px;
@@ -494,12 +462,34 @@
   transform: translate(0.5px, -0.5px);
 }
 
-.ai-sidebar button:focus-visible,
-.ai-sidebar textarea:focus-visible {
+/* Stop button (shown while the assistant is generating). */
+.ai-composer__send--stop {
+  background: #fff;
+  opacity: 1;
+}
+
+.ai-composer__send--stop:hover {
+  background: #fff;
+}
+
+.ai-stop-square {
+  width: 10px;
+  height: 10px;
+  border-radius: 2.5px;
+  background: #08090b;
+}
+
+.ai-sidebar button:focus-visible {
   outline: 1px solid rgba(255, 255, 255, 0.48);
   outline-offset: 2px;
 }
 
+/* The typing area itself never shows a focus box. */
+.ai-composer__textarea:focus,
+.ai-composer__textarea:focus-visible {
+  outline: none;
+}
+
 @media (max-width: 899px) {
   .ai-sidebar {
     width: 100vw;
@@ -510,11 +500,536 @@
   }
 }
 
+/* ---- Assistant "thinking" (streamed reasoning) ---- */
+.ai-thinking {
+  margin-bottom: 8px;
+  border-left: 2px solid var(--vp-border, rgba(255, 255, 255, 0.09));
+  padding-left: 10px;
+}
+
+.ai-thinking__summary {
+  list-style: none;
+  cursor: pointer;
+  color: var(--vp-text-faint, rgba(255, 255, 255, 0.36));
+  font-size: 11px;
+  font-weight: 560;
+  letter-spacing: 0.02em;
+  user-select: none;
+}
+
+.ai-thinking__summary::-webkit-details-marker {
+  display: none;
+}
+
+.ai-thinking__summary::before {
+  content: "›";
+  display: inline-block;
+  margin-right: 6px;
+  transition: transform 140ms ease;
+}
+
+.ai-thinking[open] .ai-thinking__summary::before {
+  transform: rotate(90deg);
+}
+
+.ai-thinking__body {
+  margin-top: 6px;
+  color: var(--vp-text-faint, rgba(255, 255, 255, 0.4));
+  font-size: 12px;
+  line-height: 1.55;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+/* ---- Per-message actions (copy / read aloud) ---- */
+.ai-msg__actions {
+  display: flex;
+  gap: 2px;
+  margin-top: 6px;
+  opacity: 0.55;
+  transition: opacity 140ms ease;
+}
+
+.ai-msg--assistant:hover .ai-msg__actions {
+  opacity: 1;
+}
+
+.ai-msg-action {
+  display: inline-grid;
+  place-items: center;
+  width: 26px;
+  height: 26px;
+  padding: 0;
+  border: 0;
+  border-radius: 7px;
+  background: transparent;
+  color: var(--vp-text-faint, rgba(255, 255, 255, 0.4));
+  cursor: pointer;
+  line-height: 0;
+  transition: color 140ms ease, background 140ms ease;
+}
+
+.ai-msg-action:hover {
+  color: var(--vp-text, rgba(255, 255, 255, 0.92));
+  background: var(--vp-hover, rgba(255, 255, 255, 0.08));
+}
+
+.ai-msg-action[data-active="true"] {
+  color: var(--vp-text, rgba(255, 255, 255, 0.92));
+}
+
+.ai-msg-action svg {
+  width: 15px;
+  height: 15px;
+}
+
+/* ---- Streaming status line (shown before the first token) ---- */
+.ai-status {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--vp-text-faint, rgba(255, 255, 255, 0.4));
+  font-size: 12.5px;
+}
+
+.ai-status__shimmer {
+  background: linear-gradient(
+    90deg,
+    rgba(255, 255, 255, 0.32) 0%,
+    rgba(255, 255, 255, 0.85) 50%,
+    rgba(255, 255, 255, 0.32) 100%
+  );
+  background-size: 200% 100%;
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  animation: ai-shimmer 1.6s linear infinite;
+}
+
+.ai-status__dots {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
+@keyframes ai-shimmer {
+  0% {
+    background-position: 200% 0;
+  }
+  100% {
+    background-position: -200% 0;
+  }
+}
+
+/* Blinking caret at the end of streaming assistant text. */
+.ai-caret {
+  display: inline-block;
+  width: 7px;
+  height: 14px;
+  margin-left: 2px;
+  transform: translateY(2px);
+  background: var(--vp-text-dim, rgba(255, 255, 255, 0.5));
+  border-radius: 1px;
+  animation: ai-caret-blink 1s steps(2, start) infinite;
+}
+
+@keyframes ai-caret-blink {
+  0%,
+  100% {
+    opacity: 0;
+  }
+  50% {
+    opacity: 1;
+  }
+}
+
+/* ---- Attachments shown inside a sent user message ---- */
+.ai-msg__attachments {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin-bottom: 7px;
+  justify-content: flex-end;
+}
+
+.ai-attach-thumb {
+  width: 66px;
+  height: 66px;
+  object-fit: cover;
+  border-radius: 9px;
+  border: 1px solid var(--vp-border, rgba(255, 255, 255, 0.09));
+  cursor: zoom-in;
+}
+
+.ai-thumb-chip__img {
+  cursor: zoom-in;
+}
+
+/* ---- Lightbox (click a thumbnail to enlarge) ---- */
+.ai-lightbox {
+  position: fixed;
+  inset: 0;
+  z-index: 99999;
+  display: grid;
+  place-items: center;
+  padding: 4vh 4vw;
+  background: rgba(0, 0, 0, 0.82);
+  backdrop-filter: blur(6px);
+  -webkit-backdrop-filter: blur(6px);
+  cursor: zoom-out;
+}
+
+.ai-lightbox__img {
+  max-width: 94vw;
+  max-height: 92vh;
+  object-fit: contain;
+  border-radius: 10px;
+  box-shadow: 0 24px 70px rgba(0, 0, 0, 0.6);
+}
+
+.ai-lightbox__close {
+  position: fixed;
+  top: 18px;
+  right: 18px;
+  z-index: 100000;
+  display: inline-grid;
+  place-items: center;
+  width: 38px;
+  height: 38px;
+  padding: 0;
+  border: 0;
+  border-radius: 10px;
+  background: rgba(255, 255, 255, 0.12);
+  color: #fff;
+  cursor: pointer;
+  line-height: 0;
+}
+
+.ai-lightbox__close:hover {
+  background: rgba(255, 255, 255, 0.22);
+}
+
+.ai-lightbox__close svg {
+  width: 20px;
+  height: 20px;
+}
+
+.ai-attach-file {
+  max-width: 180px;
+  padding: 5px 9px;
+  border-radius: 8px;
+  border: 1px solid var(--vp-border, rgba(255, 255, 255, 0.09));
+  background: var(--vp-panel, rgba(255, 255, 255, 0.045));
+  color: var(--vp-text-dim, rgba(255, 255, 255, 0.5));
+  font-size: 11px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* ---- Composer attachment chips (pending, before send) ---- */
+.ai-composer__chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin-bottom: 8px;
+}
+
+.ai-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  max-width: 190px;
+  padding: 4px 6px 4px 4px;
+  border: 1px solid var(--vp-border, rgba(255, 255, 255, 0.09));
+  border-radius: 9px;
+  background: var(--vp-panel, rgba(255, 255, 255, 0.045));
+}
+
+.ai-chip__thumb {
+  width: 26px;
+  height: 26px;
+  object-fit: cover;
+  border-radius: 6px;
+}
+
+.ai-chip__icon {
+  display: inline-grid;
+  place-items: center;
+  width: 26px;
+  height: 26px;
+  border-radius: 6px;
+  background: rgba(255, 255, 255, 0.06);
+  color: var(--vp-text-dim, rgba(255, 255, 255, 0.5));
+  font-size: 13px;
+}
+
+.ai-chip__label {
+  overflow: hidden;
+  color: var(--vp-text-dim, rgba(255, 255, 255, 0.6));
+  font-size: 11px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.ai-chip__remove {
+  display: inline-grid;
+  place-items: center;
+  width: 18px;
+  height: 18px;
+  flex: 0 0 18px;
+  padding: 0;
+  border: 0;
+  border-radius: 5px;
+  background: transparent;
+  color: var(--vp-text-faint, rgba(255, 255, 255, 0.36));
+  cursor: pointer;
+  line-height: 0;
+}
+
+.ai-chip__remove:hover {
+  color: var(--vp-text, rgba(255, 255, 255, 0.92));
+  background: var(--vp-hover, rgba(255, 255, 255, 0.1));
+}
+
+.ai-chip__remove svg {
+  width: 12px;
+  height: 12px;
+}
+
+/* ---- Composer tools (plus / camera / model picker) ---- */
+.ai-composer__tools {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  min-width: 0;
+}
+
+/* Right side of the composer footer: model picker directly beside Send. */
+.ai-composer__right {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+
+.ai-composer__right .ai-model-picker {
+  max-width: 190px;
+}
+
+.ai-hidden-file {
+  display: none;
+}
+
+.ai-tool-btn {
+  display: inline-grid;
+  place-items: center;
+  width: 31px;
+  height: 31px;
+  flex: 0 0 31px;
+  padding: 0;
+  border: 1px solid var(--vp-border, rgba(255, 255, 255, 0.09));
+  border-radius: 9px;
+  background: transparent;
+  color: var(--vp-text-dim, rgba(255, 255, 255, 0.55));
+  cursor: pointer;
+  line-height: 0;
+  transition: color 140ms ease, background 140ms ease, border-color 140ms ease;
+}
+
+.ai-tool-btn:hover:not(:disabled) {
+  color: var(--vp-text, rgba(255, 255, 255, 0.92));
+  background: var(--vp-hover, rgba(255, 255, 255, 0.08));
+  border-color: var(--vp-border-strong, rgba(255, 255, 255, 0.16));
+}
+
+.ai-tool-btn:disabled {
+  cursor: default;
+  opacity: 0.4;
+}
+
+.ai-tool-btn[data-active="true"] {
+  color: var(--vp-text, rgba(255, 255, 255, 0.92));
+  background: var(--vp-hover, rgba(255, 255, 255, 0.12));
+  border-color: var(--vp-border-strong, rgba(255, 255, 255, 0.22));
+}
+
+.ai-tool-btn svg {
+  width: 16px;
+  height: 16px;
+}
+
+/* ---- Drag-to-resize handle (left edge) ---- */
+.ai-resize-handle {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 8px;
+  height: 100%;
+  z-index: 5;
+  cursor: ew-resize;
+  touch-action: none;
+}
+
+.ai-resize-handle::after {
+  content: "";
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 2px;
+  height: 100%;
+  background: transparent;
+  transition: background 140ms ease;
+}
+
+.ai-resize-handle:hover::after {
+  background: var(--vp-border-strong, rgba(255, 255, 255, 0.28));
+}
+
+/* ---- Welcome / how-to summary (empty state) ---- */
+.ai-welcome {
+  margin: auto;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  text-align: center;
+  gap: 12px;
+  max-width: 300px;
+  padding: 24px 8px;
+}
+
+.ai-welcome__mark {
+  display: inline-grid;
+  place-items: center;
+  width: 44px;
+  height: 44px;
+  border: 1px solid var(--vp-border-strong, rgba(255, 255, 255, 0.16));
+  border-radius: 12px;
+  background: var(--vp-panel, rgba(255, 255, 255, 0.045));
+  color: rgba(255, 255, 255, 0.75);
+}
+
+.ai-welcome__mark svg {
+  width: 24px;
+  height: 24px;
+}
+
+.ai-welcome__title {
+  margin: 0;
+  font-size: 17px;
+  font-weight: 650;
+  letter-spacing: -0.01em;
+  color: var(--vp-text, rgba(255, 255, 255, 0.92));
+}
+
+.ai-welcome__text {
+  margin: 0;
+  font-size: 12.5px;
+  line-height: 1.6;
+  color: var(--vp-text-dim, rgba(255, 255, 255, 0.5));
+}
+
+.ai-welcome__text strong {
+  color: var(--vp-text, rgba(255, 255, 255, 0.85));
+  font-weight: 650;
+}
+
+/* ---- Compact image thumbnail chips (fit 4 captured views on one row) ---- */
+.ai-thumb-chip {
+  position: relative;
+  flex: 0 0 auto;
+  width: 62px;
+  height: 62px;
+  border-radius: 9px;
+  overflow: hidden;
+  border: 1px solid var(--vp-border, rgba(255, 255, 255, 0.09));
+}
+
+.ai-thumb-chip__img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+}
+
+.ai-thumb-chip__remove {
+  position: absolute;
+  top: 2px;
+  right: 2px;
+  display: inline-grid;
+  place-items: center;
+  width: 17px;
+  height: 17px;
+  padding: 0;
+  border: 0;
+  border-radius: 5px;
+  background: rgba(0, 0, 0, 0.6);
+  color: #fff;
+  cursor: pointer;
+  line-height: 0;
+}
+
+.ai-thumb-chip__remove svg {
+  width: 11px;
+  height: 11px;
+}
+
+/* ---- File-type icon badge (composer chip + sent message) ---- */
+.ai-chip__type,
+.ai-attach-file__icon {
+  display: inline-grid;
+  place-items: center;
+  width: 26px;
+  height: 26px;
+  flex: 0 0 26px;
+  border-radius: 6px;
+  background: rgba(255, 255, 255, 0.06);
+  color: var(--vp-text-dim, rgba(255, 255, 255, 0.6));
+}
+
+.ai-chip__type svg,
+.ai-attach-file__icon svg {
+  width: 15px;
+  height: 15px;
+}
+
+.ai-chip__type[data-type="pdf"],
+.ai-attach-file__icon[data-type="pdf"] {
+  background: rgba(232, 89, 89, 0.16);
+  color: #f0a0a0;
+}
+
+.ai-chip__type[data-type="scan"],
+.ai-attach-file__icon[data-type="scan"] {
+  background: rgba(110, 168, 254, 0.16);
+  color: #a8c8ff;
+}
+
+.ai-chip__type[data-type="image"],
+.ai-attach-file__icon[data-type="image"] {
+  background: rgba(120, 200, 140, 0.16);
+  color: #a6d8b4;
+}
+
+.ai-attach-file {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+}
+
+.ai-attach-file__name {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 @media (prefers-reduced-motion: reduce) {
   .ai-sidebar,
   .ai-typing__dot,
   .ai-model-picker__dot,
-  .ai-model-picker__button > svg {
+  .ai-model-picker__button > svg,
+  .ai-status__shimmer,
+  .ai-caret {
     animation: none;
     transition: none;
   }
diff --git a/PanTS-Demo/src/components/AIAssistant/AISidebar.tsx b/PanTS-Demo/src/components/AIAssistant/AISidebar.tsx
index f880f73..1f885a9 100644
--- a/PanTS-Demo/src/components/AIAssistant/AISidebar.tsx
+++ b/PanTS-Demo/src/components/AIAssistant/AISidebar.tsx
@@ -1,15 +1,22 @@
-// Trigger typecheck using the latest AI assistant files.
 import React, { useCallback, useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
 import { API_BASE } from "../../helpers/constants";
 import type {
   AIAction,
   AIModelInfo,
   AISidebarProps,
+  ChatAttachment,
   ChatMessage,
 } from "./types";
 import "./AISidebar.css";
 
-const MODEL_STORAGE_KEY = "bodymaps-ai-model";
+// Bumped to v2 so a previously-stored reasoning model (e.g. qwen3) is reset —
+// the default now prefers a non-reasoning model that never leaks "thinking".
+const MODEL_STORAGE_KEY = "bodymaps-ai-model-v2";
+
+// Reasoning models emit a chain-of-thought that can leak into the answer on
+// older Ollama; we avoid picking them as the initial default.
+const REASONING_MODEL = /qwen3|deepseek-r1|-r1\b|:think|marco-o1|qwq/i;
 
 const SendIcon = () => (
   <svg
@@ -39,6 +46,35 @@ const CloseIcon = () => (
   </svg>
 );
 
+const PlusIcon = () => (
+  <svg
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    strokeWidth={2}
+    strokeLinecap="round"
+    strokeLinejoin="round"
+    aria-hidden="true"
+  >
+    <path d="M12 5v14M5 12h14" />
+  </svg>
+);
+
+const CameraIcon = () => (
+  <svg
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    strokeWidth={1.8}
+    strokeLinecap="round"
+    strokeLinejoin="round"
+    aria-hidden="true"
+  >
+    <path d="M4 8h3l1.6-2.2a1 1 0 0 1 .8-.4h5.2a1 1 0 0 1 .8.4L20 8h0a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2Z" />
+    <circle cx="12" cy="13" r="3.2" />
+  </svg>
+);
+
 const BotIcon = () => (
   <svg
     viewBox="0 0 24 24"
@@ -56,6 +92,50 @@ const BotIcon = () => (
   </svg>
 );
 
+const CopyIcon = () => (
+  <svg
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    strokeWidth={1.7}
+    strokeLinecap="round"
+    strokeLinejoin="round"
+    aria-hidden="true"
+  >
+    <rect x="9" y="9" width="12" height="12" rx="2.5" />
+    <path d="M6 15a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2" />
+  </svg>
+);
+
+const SpeakerIcon = () => (
+  <svg
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    strokeWidth={1.7}
+    strokeLinecap="round"
+    strokeLinejoin="round"
+    aria-hidden="true"
+  >
+    <path d="M11 5 6 9H3v6h3l5 4V5Z" />
+    <path d="M15.5 8.5a5 5 0 0 1 0 7M18 6a8 8 0 0 1 0 12" />
+  </svg>
+);
+
+const StopIcon = () => (
+  <svg
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    strokeWidth={1.7}
+    strokeLinecap="round"
+    strokeLinejoin="round"
+    aria-hidden="true"
+  >
+    <rect x="6" y="6" width="12" height="12" rx="2" />
+  </svg>
+);
+
 const ChevronIcon = () => (
   <svg
     viewBox="0 0 20 20"
@@ -70,6 +150,46 @@ const ChevronIcon = () => (
   </svg>
 );
 
+// Attachment type → a distinct little icon (PDF / image / scan / generic file).
+type FileType = "pdf" | "image" | "scan" | "file";
+
+function fileTypeOf(name: string): FileType {
+  const n = name.toLowerCase();
+  if (n.endsWith(".pdf")) return "pdf";
+  if (/\.(png|jpe?g|gif|webp|bmp|tiff?)$/.test(n)) return "image";
+  if (/\.(nii|nii\.gz|dcm|dicom|nrrd|mha|mhd)$/.test(n)) return "scan";
+  return "file";
+}
+
+const DocIcon = () => (
+  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={1.7} strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+    <path d="M14 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V8Z" />
+    <path d="M14 3v5h5" />
+  </svg>
+);
+
+const ImageFileIcon = () => (
+  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={1.7} strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+    <rect x="3" y="4" width="18" height="16" rx="2.4" />
+    <circle cx="8.5" cy="9" r="1.6" />
+    <path d="m4 17 5-5 4 4 3-3 4 4" />
+  </svg>
+);
+
+const ScanFileIcon = () => (
+  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={1.7} strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+    <path d="M4 8V6a2 2 0 0 1 2-2h2M16 4h2a2 2 0 0 1 2 2v2M20 16v2a2 2 0 0 1-2 2h-2M8 20H6a2 2 0 0 1-2-2v-2" />
+    <circle cx="12" cy="12" r="3.4" />
+  </svg>
+);
+
+function AttachmentTypeIcon({ name }: { name: string }) {
+  const type = fileTypeOf(name);
+  if (type === "image") return <ImageFileIcon />;
+  if (type === "scan") return <ScanFileIcon />;
+  return <DocIcon />;
+}
+
 const CheckIcon = () => (
   <svg
     viewBox="0 0 20 20"
@@ -84,56 +204,53 @@ const CheckIcon = () => (
   </svg>
 );
 
-let messageCounter = 0;
+let idCounter = 0;
+function makeId(prefix = "id") {
+  idCounter += 1;
+  return `${prefix}-${Date.now()}-${idCounter}`;
+}
 
-function makeId() {
-  messageCounter += 1;
-  return `msg-${Date.now()}-${messageCounter}`;
+function readFileAsDataURL(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result));
+    reader.onerror = () => reject(reader.error);
+    reader.readAsDataURL(file);
+  });
 }
 
+// Minimal markdown: **bold** and line breaks. Kept intentionally small so the
+// assistant text stays clean and minimalist rather than heavily styled.
 function renderMessageText(content: string) {
   return content.split("\n").map((line, lineIndex, lines) => {
     const parts = line.split(/(\*\*[^*]+\*\*)/g);
-
     return (
       <React.Fragment key={`${lineIndex}-${line}`}>
         {parts.map((part, partIndex) => {
           if (part.startsWith("**") && part.endsWith("**")) {
-            return (
-              <strong key={`${lineIndex}-${partIndex}`}>
-                {part.slice(2, -2)}
-              </strong>
-            );
+            return <strong key={`${lineIndex}-${partIndex}`}>{part.slice(2, -2)}</strong>;
           }
-
           return (
-            <React.Fragment key={`${lineIndex}-${partIndex}`}>
-              {part}
-            </React.Fragment>
+            <React.Fragment key={`${lineIndex}-${partIndex}`}>{part}</React.Fragment>
           );
         })}
-
         {lineIndex < lines.length - 1 ? <br /> : null}
       </React.Fragment>
     );
   });
 }
 
-const SUGGESTION_CHIPS = [
-  "Segment the liver and tell me its volume",
-  "What does the liver do?",
-  "What organs are visible in this scan?",
-];
-
-type AICommandResponse = {
-  reply?: string;
-  actions?: AIAction[];
-  source?: string;
-  model?: string | null;
-};
-
 type ModelState = "loading" | "ollama" | "fallback";
 
+type StreamEvent =
+  | { type: "status"; text?: string }
+  | { type: "thinking"; delta?: string }
+  | { type: "reply"; delta?: string }
+  | { type: "actions"; actions?: AIAction[] }
+  | { type: "final"; reply?: string; actions?: AIAction[]; source?: string; model?: string | null }
+  | { type: "done" }
+  | { type: "error"; message?: string };
+
 export default function AISidebar({
   open,
   onClose,
@@ -145,32 +262,42 @@ export default function AISidebar({
   organReferences = [],
   demographics = null,
   actions,
+  captureViewport,
+  getMaskLegend,
+  onResize,
+  onResizeEnd,
 }: AISidebarProps) {
   const [messages, setMessages] = useState<ChatMessage[]>([]);
   const [input, setInput] = useState("");
+  const [attachments, setAttachments] = useState<ChatAttachment[]>([]);
   const [loading, setLoading] = useState(false);
+  const [capturing, setCapturing] = useState(false);
   const [models, setModels] = useState<AIModelInfo[]>([]);
   const [selectedModel, setSelectedModel] = useState("");
   const [modelState, setModelState] = useState<ModelState>("loading");
   const [modelMenuOpen, setModelMenuOpen] = useState(false);
+  const [copiedId, setCopiedId] = useState<string | null>(null);
+  const [speakingId, setSpeakingId] = useState<string | null>(null);
+  const [lightboxUrl, setLightboxUrl] = useState<string | null>(null);
 
   const chatEndRef = useRef<HTMLDivElement>(null);
+  const chatScrollRef = useRef<HTMLDivElement>(null);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
   const modelPickerRef = useRef<HTMLDivElement>(null);
+  const fileInputRef = useRef<HTMLInputElement>(null);
+  const abortRef = useRef<AbortController | null>(null);
+  // Whether the chat is scrolled to (near) the bottom. Only auto-scroll when it
+  // is, so scrolling up to read during generation isn't yanked back down.
+  const pinnedToBottomRef = useRef(true);
 
   const loadModels = useCallback(async () => {
     setModelState("loading");
-
     try {
       const response = await fetch(`${API_BASE}/api/ai-models`);
       const data = await response.json();
-      if (!response.ok) {
-        throw new Error(data.error || `HTTP ${response.status}`);
-      }
+      if (!response.ok) throw new Error(data.error || `HTTP ${response.status}`);
 
-      const nextModels: AIModelInfo[] = Array.isArray(data.models)
-        ? data.models
-        : [];
+      const nextModels: AIModelInfo[] = Array.isArray(data.models) ? data.models : [];
       setModels(nextModels);
 
       if (!data.available || nextModels.length === 0) {
@@ -179,18 +306,17 @@ export default function AISidebar({
         return;
       }
 
-      const storedModel =
-        window.localStorage.getItem(MODEL_STORAGE_KEY) ?? "";
-      const defaultModel = String(
-        data.default_model || nextModels[0].name
-      );
-      const nextSelection = nextModels.some(
-        (model) => model.name === storedModel
-      )
+      const storedModel = window.localStorage.getItem(MODEL_STORAGE_KEY) ?? "";
+      const backendDefault = String(data.default_model || "");
+      // Prefer a non-reasoning model as the initial default (clean output),
+      // unless the user has already picked one this session.
+      const cleanModel = nextModels.find((model) => !REASONING_MODEL.test(model.name));
+      const nextSelection = nextModels.some((model) => model.name === storedModel)
         ? storedModel
-        : nextModels.some((model) => model.name === defaultModel)
-          ? defaultModel
-          : nextModels[0].name;
+        : !REASONING_MODEL.test(backendDefault) &&
+            nextModels.some((model) => model.name === backendDefault)
+          ? backendDefault
+          : cleanModel?.name ?? (backendDefault || nextModels[0].name);
 
       setSelectedModel(nextSelection);
       setModelState("ollama");
@@ -204,29 +330,35 @@ export default function AISidebar({
 
   useEffect(() => {
     if (!open) return;
-
     setModelMenuOpen(false);
     void loadModels();
-    const focusTimer = window.setTimeout(() => {
-      textareaRef.current?.focus();
-    }, 180);
-
+    const focusTimer = window.setTimeout(() => textareaRef.current?.focus(), 180);
     return () => window.clearTimeout(focusTimer);
   }, [open, loadModels]);
 
   useEffect(() => {
+    abortRef.current?.abort();
     setMessages([]);
     setInput("");
+    setAttachments([]);
     setModelMenuOpen(false);
   }, [caseId, sessionId]);
 
+  // Auto-scroll to the newest content ONLY when the user is already near the
+  // bottom. If they've scrolled up to read, leave them where they are.
   useEffect(() => {
-    chatEndRef.current?.scrollIntoView({
-      behavior: "smooth",
-      block: "end",
-    });
+    if (pinnedToBottomRef.current) {
+      chatEndRef.current?.scrollIntoView({ behavior: "smooth", block: "end" });
+    }
   }, [messages, loading]);
 
+  const handleChatScroll = useCallback(() => {
+    const el = chatScrollRef.current;
+    if (!el) return;
+    const distanceFromBottom = el.scrollHeight - el.scrollTop - el.clientHeight;
+    pinnedToBottomRef.current = distanceFromBottom < 80;
+  }, []);
+
   const closeSidebar = useCallback(() => {
     setModelMenuOpen(false);
     onClose();
@@ -234,7 +366,6 @@ export default function AISidebar({
 
   useEffect(() => {
     if (!open) return;
-
     const handlePointerDown = (event: PointerEvent) => {
       if (
         modelMenuOpen &&
@@ -244,19 +375,13 @@ export default function AISidebar({
         setModelMenuOpen(false);
       }
     };
-
     const handleEscape = (event: KeyboardEvent) => {
       if (event.key !== "Escape") return;
-      if (modelMenuOpen) {
-        setModelMenuOpen(false);
-      } else {
-        closeSidebar();
-      }
+      if (modelMenuOpen) setModelMenuOpen(false);
+      else closeSidebar();
     };
-
     window.addEventListener("pointerdown", handlePointerDown);
     window.addEventListener("keydown", handleEscape);
-
     return () => {
       window.removeEventListener("pointerdown", handlePointerDown);
       window.removeEventListener("keydown", handleEscape);
@@ -266,7 +391,6 @@ export default function AISidebar({
   const selectModel = (value: string) => {
     setSelectedModel(value);
     setModelMenuOpen(false);
-
     if (value) {
       window.localStorage.setItem(MODEL_STORAGE_KEY, value);
       setModelState("ollama");
@@ -276,19 +400,22 @@ export default function AISidebar({
     }
   };
 
-  const handleInput = (
-    event: React.ChangeEvent<HTMLTextAreaElement>
-  ) => {
+  const handleInput = (event: React.ChangeEvent<HTMLTextAreaElement>) => {
     setInput(event.target.value);
-
     const element = event.target;
     element.style.height = "auto";
-    element.style.height = `${Math.min(
-      element.scrollHeight,
-      124
-    )}px`;
+    element.style.height = `${Math.min(element.scrollHeight, 124)}px`;
   };
 
+  const updateMessage = useCallback(
+    (id: string, updater: (message: ChatMessage) => ChatMessage) => {
+      setMessages((previous) =>
+        previous.map((message) => (message.id === id ? updater(message) : message))
+      );
+    },
+    []
+  );
+
   const executeAction = useCallback(
     async (action: AIAction): Promise<void> => {
       switch (action.type) {
@@ -350,109 +477,373 @@ export default function AISidebar({
         try {
           await executeAction(action);
         } catch (error) {
-          console.error(
-            "[BodyMaps AI action error]",
-            error,
-            action
-          );
+          console.error("[BodyMaps AI action error]", error, action);
         }
       }
     },
     [executeAction]
   );
 
+  // ---- Attachments ---------------------------------------------------------
+
+  const addFiles = useCallback(async (files: FileList | File[]) => {
+    const list = Array.from(files);
+    const next: ChatAttachment[] = [];
+    for (const file of list) {
+      if (file.type.startsWith("image/")) {
+        try {
+          const dataUrl = await readFileAsDataURL(file);
+          next.push({ id: makeId("att"), name: file.name, kind: "image", dataUrl, source: "upload" });
+        } catch {
+          next.push({ id: makeId("att"), name: file.name, kind: "file", source: "upload" });
+        }
+      } else {
+        next.push({ id: makeId("att"), name: file.name, kind: "file", source: "upload" });
+      }
+    }
+    if (next.length) setAttachments((previous) => [...previous, ...next]);
+  }, []);
+
+  const handleFilePick = (event: React.ChangeEvent<HTMLInputElement>) => {
+    if (event.target.files && event.target.files.length) void addFiles(event.target.files);
+    event.target.value = "";
+  };
+
+  const handleCapture = useCallback(async () => {
+    if (!captureViewport || capturing) return;
+    // Toggle: if screenshots are already attached, one more click clears them
+    // all instead of stacking another set.
+    if (attachments.some((att) => att.source === "screenshot")) {
+      setAttachments((previous) => previous.filter((att) => att.source !== "screenshot"));
+      return;
+    }
+    setCapturing(true);
+    try {
+      const shots = await captureViewport();
+      if (!shots.length) return;
+      const next: ChatAttachment[] = shots.map((shot) => ({
+        id: makeId("shot"),
+        name: `${shot.name} view`,
+        kind: "image",
+        dataUrl: shot.dataUrl,
+        label: shot.name,
+        source: "screenshot",
+      }));
+      setAttachments((previous) => [...previous, ...next]);
+    } catch (error) {
+      console.error("[BodyMaps AI capture error]", error);
+    } finally {
+      setCapturing(false);
+    }
+  }, [captureViewport, capturing, attachments]);
+
+  const removeAttachment = (id: string) => {
+    setAttachments((previous) => previous.filter((item) => item.id !== id));
+  };
+
+  // ---- Copy / read aloud (per assistant message) ---------------------------
+
+  const handleCopy = useCallback(async (id: string, text: string) => {
+    try {
+      await navigator.clipboard.writeText(text);
+      setCopiedId(id);
+      window.setTimeout(() => setCopiedId((current) => (current === id ? null : current)), 1400);
+    } catch (error) {
+      console.error("[BodyMaps AI copy error]", error);
+    }
+  }, []);
+
+  const handleSpeak = useCallback(
+    (id: string, text: string) => {
+      const synth = window.speechSynthesis;
+      if (!synth) return;
+      // Toggle: clicking the speaker on the message that's talking stops it.
+      if (speakingId === id) {
+        synth.cancel();
+        setSpeakingId(null);
+        return;
+      }
+      synth.cancel();
+      const utterance = new SpeechSynthesisUtterance(text);
+      utterance.rate = 1.02;
+      utterance.onend = () => setSpeakingId((current) => (current === id ? null : current));
+      utterance.onerror = () => setSpeakingId((current) => (current === id ? null : current));
+      setSpeakingId(id);
+      synth.speak(utterance);
+    },
+    [speakingId]
+  );
+
+  // ---- Drag-to-resize (left edge) ------------------------------------------
+
+  const startResize = useCallback(
+    (event: React.PointerEvent) => {
+      if (!onResize) return;
+      event.preventDefault();
+      const move = (e: PointerEvent) => onResize(e.clientX);
+      const up = () => {
+        window.removeEventListener("pointermove", move);
+        window.removeEventListener("pointerup", up);
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+        onResizeEnd?.();
+      };
+      document.body.style.cursor = "ew-resize";
+      document.body.style.userSelect = "none";
+      window.addEventListener("pointermove", move);
+      window.addEventListener("pointerup", up);
+    },
+    [onResize, onResizeEnd]
+  );
+
+  // Stop any narration when the panel closes or the case changes.
+  useEffect(() => {
+    if (!open) {
+      window.speechSynthesis?.cancel();
+      setSpeakingId(null);
+    }
+  }, [open]);
+
+  useEffect(() => {
+    return () => {
+      window.speechSynthesis?.cancel();
+    };
+  }, []);
+
+  // ---- Streaming send ------------------------------------------------------
+
+  const streamResponse = useCallback(
+    async (
+      assistantId: string,
+      payload: Record<string, unknown>,
+      signal?: AbortSignal
+    ): Promise<boolean> => {
+      const response = await fetch(`${API_BASE}/api/ai-command-stream`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal,
+      });
+      if (!response.ok || !response.body) throw new Error(`HTTP ${response.status}`);
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let actionsApplied = false;
+
+      const handleEvent = (event: StreamEvent) => {
+        switch (event.type) {
+          case "status":
+            updateMessage(assistantId, (m) => ({ ...m, status: event.text ?? "" }));
+            break;
+          case "thinking":
+            updateMessage(assistantId, (m) => ({
+              ...m,
+              thinking: (m.thinking ?? "") + (event.delta ?? ""),
+            }));
+            break;
+          case "reply":
+            updateMessage(assistantId, (m) => ({
+              ...m,
+              content: m.content + (event.delta ?? ""),
+              status: undefined,
+            }));
+            break;
+          case "actions":
+            if (Array.isArray(event.actions) && event.actions.length) {
+              actionsApplied = true;
+              void applyReturnedActions(event.actions);
+            }
+            break;
+          case "final":
+            if (typeof event.reply === "string") {
+              updateMessage(assistantId, (m) => ({ ...m, content: event.reply as string, status: undefined }));
+            }
+            if (!actionsApplied && Array.isArray(event.actions) && event.actions.length) {
+              actionsApplied = true;
+              void applyReturnedActions(event.actions);
+            }
+            break;
+          case "error":
+            updateMessage(assistantId, (m) => ({
+              ...m,
+              content:
+                m.content ||
+                event.message ||
+                "The assistant ran into an error while answering.",
+              status: undefined,
+            }));
+            break;
+          case "done":
+            break;
+        }
+      };
+
+      // Read the NDJSON stream line by line.
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+          const line = buffer.slice(0, newlineIndex).trim();
+          buffer = buffer.slice(newlineIndex + 1);
+          if (line) {
+            try {
+              handleEvent(JSON.parse(line) as StreamEvent);
+            } catch (error) {
+              console.warn("[BodyMaps AI stream parse]", error, line);
+            }
+          }
+          newlineIndex = buffer.indexOf("\n");
+        }
+      }
+
+      const tail = buffer.trim();
+      if (tail) {
+        try {
+          handleEvent(JSON.parse(tail) as StreamEvent);
+        } catch {
+          /* ignore trailing partial */
+        }
+      }
+      return true;
+    },
+    [applyReturnedActions, updateMessage]
+  );
+
+  // Non-streaming fallback for environments where the stream endpoint is
+  // unavailable (older backend, proxy that buffers the response, etc.).
+  const sendNonStreaming = useCallback(
+    async (assistantId: string, payload: Record<string, unknown>, signal?: AbortSignal) => {
+      const response = await fetch(`${API_BASE}/api/ai-command`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal,
+      });
+      const data = await response.json();
+      if (!response.ok) throw new Error(data.reply || `HTTP ${response.status}`);
+      const returnedActions: AIAction[] = Array.isArray(data.actions) ? data.actions : [];
+      if (returnedActions.length) void applyReturnedActions(returnedActions);
+      updateMessage(assistantId, (m) => ({
+        ...m,
+        content: data.reply ?? "Done.",
+        status: undefined,
+      }));
+    },
+    [applyReturnedActions, updateMessage]
+  );
+
   const handleSend = useCallback(
     async (overrideText?: string) => {
       const text = (overrideText ?? input).trim();
-      if (!text || loading) return;
+      const outgoingAttachments = attachments;
+      if ((!text && outgoingAttachments.length === 0) || loading) return;
 
       const conversation = messages
-        .filter(
-          (message) =>
-            message.role === "user" ||
-            message.role === "assistant"
-        )
+        .filter((message) => message.role === "user" || message.role === "assistant")
         .slice(-12)
-        .map((message) => ({
-          role: message.role,
-          content: message.content,
-        }));
+        .map((message) => ({ role: message.role, content: message.content }));
 
       setInput("");
-      if (textareaRef.current) {
-        textareaRef.current.style.height = "auto";
-      }
+      setAttachments([]);
+      if (textareaRef.current) textareaRef.current.style.height = "auto";
+
+      // A new turn: pin to the bottom so the reply is visible as it starts.
+      pinnedToBottomRef.current = true;
+
+      const userId = makeId("user");
+      const assistantId = makeId("assistant");
 
       setMessages((previous) => [
         ...previous,
         {
-          id: makeId(),
+          id: userId,
           role: "user",
           content: text,
           timestamp: Date.now(),
+          attachments: outgoingAttachments.length ? outgoingAttachments : undefined,
+        },
+        {
+          id: assistantId,
+          role: "assistant",
+          content: "",
+          timestamp: Date.now(),
+          streaming: true,
+          status: "Thinking",
         },
       ]);
       setLoading(true);
 
-      try {
-        const response = await fetch(`${API_BASE}/api/ai-command`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            message: text,
-            conversation,
-            case_id: caseId,
-            session_id: sessionId ?? null,
-            available_organs: availableOrgans,
-            viewer_state: viewerState,
-            organ_metrics: organMetrics,
-            organ_references: organReferences,
-            demographics,
-            model: selectedModel || null,
-          }),
-        });
-
-        const data = (await response.json()) as AICommandResponse;
-        if (!response.ok) {
-          throw new Error(data.reply || `HTTP ${response.status}`);
-        }
+      const images = outgoingAttachments
+        .filter((item) => item.kind === "image" && item.dataUrl)
+        .map((item) => item.dataUrl as string);
 
-        const returnedActions = Array.isArray(data.actions)
-          ? data.actions
-          : [];
-        if (returnedActions.length > 0) {
-          void applyReturnedActions(returnedActions);
-        }
+      const fileNames = outgoingAttachments
+        .filter((item) => item.kind === "file")
+        .map((item) => item.name);
+
+      const composedMessage = fileNames.length
+        ? `${text}\n\n[Attached files: ${fileNames.join(", ")}]`.trim()
+        : text;
+
+      // When screenshots are attached, include the color→organ legend so the
+      // vision model can identify each colored region.
+      const maskLegend =
+        images.length && getMaskLegend ? getMaskLegend() : [];
 
-        setMessages((previous) => [
-          ...previous,
-          {
-            id: makeId(),
-            role: "assistant",
-            content: data.reply ?? "Done.",
-            timestamp: Date.now(),
-          },
-        ]);
-      } catch (error) {
-        console.error("[BodyMaps AI send error]", error);
-        setMessages((previous) => [
-          ...previous,
-          {
-            id: makeId(),
-            role: "assistant",
-            content:
-              "The assistant service is unavailable right now. Viewer controls are still available from the left panel.",
-            timestamp: Date.now(),
-          },
-        ]);
+      const payload: Record<string, unknown> = {
+        message: composedMessage,
+        conversation,
+        case_id: caseId,
+        session_id: sessionId ?? null,
+        available_organs: availableOrgans,
+        viewer_state: viewerState,
+        organ_metrics: organMetrics,
+        organ_references: organReferences,
+        demographics,
+        model: selectedModel || null,
+        images,
+        mask_legend: maskLegend,
+      };
+
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const isAbort = (e: unknown) =>
+        e instanceof DOMException ? e.name === "AbortError" : (e as { name?: string })?.name === "AbortError";
+
+      try {
+        await streamResponse(assistantId, payload, controller.signal);
+      } catch (streamError) {
+        if (isAbort(streamError)) {
+          // User pressed Stop — keep whatever was streamed, no error.
+        } else {
+          console.warn("[BodyMaps AI stream] falling back:", streamError);
+          try {
+            await sendNonStreaming(assistantId, payload, controller.signal);
+          } catch (error) {
+            if (!isAbort(error)) {
+              console.error("[BodyMaps AI send error]", error);
+              updateMessage(assistantId, (m) => ({
+                ...m,
+                content:
+                  m.content ||
+                  "The assistant service is unavailable right now. Viewer controls are still available from the left panel.",
+                status: undefined,
+              }));
+            }
+          }
+        }
       } finally {
+        updateMessage(assistantId, (m) => ({ ...m, streaming: false, status: undefined }));
         setLoading(false);
+        abortRef.current = null;
       }
     },
     [
       input,
+      attachments,
       loading,
       messages,
       caseId,
@@ -463,13 +854,18 @@ export default function AISidebar({
       organReferences,
       demographics,
       selectedModel,
-      applyReturnedActions,
+      getMaskLegend,
+      streamResponse,
+      sendNonStreaming,
+      updateMessage,
     ]
   );
 
-  const handleKeyDown = (
-    event: React.KeyboardEvent<HTMLTextAreaElement>
-  ) => {
+  const handleStop = useCallback(() => {
+    abortRef.current?.abort();
+  }, []);
+
+  const handleKeyDown = (event: React.KeyboardEvent<HTMLTextAreaElement>) => {
     if (event.key === "Enter" && !event.shiftKey) {
       event.preventDefault();
       void handleSend();
@@ -481,7 +877,9 @@ export default function AISidebar({
       ? "Loading models"
       : modelState === "fallback"
         ? "Local fallback"
-        : selectedModel || "Automatic";
+        : selectedModel || models[0]?.name || "Model";
+
+  const canSend = !loading && (input.trim().length > 0 || attachments.length > 0);
 
   return (
     <aside
@@ -490,16 +888,24 @@ export default function AISidebar({
       aria-label="BodyMaps AI assistant"
       aria-hidden={!open}
     >
+      {onResize && (
+        <div
+          className="ai-resize-handle"
+          onPointerDown={startResize}
+          role="separator"
+          aria-orientation="vertical"
+          aria-label="Resize the AI panel"
+          title="Drag to resize"
+        />
+      )}
+
       <header className="ai-sidebar__header">
         <div className="ai-sidebar__brand">
           <span className="ai-sidebar__mark">
             <BotIcon />
           </span>
-          <span className="ai-sidebar__title">
-            BodyMaps AI
-          </span>
+          <span className="ai-sidebar__title">BodyMaps AI</span>
         </div>
-
         <button
           className="ai-sidebar__close"
           onClick={closeSidebar}
@@ -516,54 +922,143 @@ export default function AISidebar({
         role="log"
         aria-live="polite"
         aria-relevant="additions"
+        ref={chatScrollRef}
+        onScroll={handleChatScroll}
       >
-        {messages.map((message) => (
-          <div
-            key={message.id}
-            className={`ai-msg ai-msg--${message.role}`}
-          >
-            <div className="ai-msg__content">
-              {renderMessageText(message.content)}
-            </div>
+        {messages.length === 0 && !loading && (
+          <div className="ai-welcome">
+            <span className="ai-welcome__mark">
+              <BotIcon />
+            </span>
+            <h2 className="ai-welcome__title">BodyMaps AI</h2>
+            <p className="ai-welcome__text">
+              Ask me anything about this scan or medicine in general. Try “segment
+              the liver and tell me its volume,” or attach a file and CT views.
+            </p>
           </div>
-        ))}
+        )}
 
-        {loading && (
-          <div className="ai-msg ai-msg--assistant">
-            <div
-              className="ai-typing"
-              aria-label="BodyMaps AI is thinking"
-            >
-              <span className="ai-typing__dot" />
-              <span className="ai-typing__dot" />
-              <span className="ai-typing__dot" />
+        {messages.map((message) =>
+          message.role === "user" ? (
+            <div key={message.id} className="ai-msg ai-msg--user">
+              {message.attachments && message.attachments.length > 0 && (
+                <div className="ai-msg__attachments">
+                  {message.attachments.map((att) =>
+                    att.kind === "image" && att.dataUrl ? (
+                      <img
+                        key={att.id}
+                        className="ai-attach-thumb"
+                        src={att.dataUrl}
+                        alt={att.name}
+                        title={`${att.name} — click to enlarge`}
+                        onClick={() => setLightboxUrl(att.dataUrl ?? null)}
+                      />
+                    ) : (
+                      <span key={att.id} className="ai-attach-file" title={att.name}>
+                        <span className="ai-attach-file__icon" data-type={fileTypeOf(att.name)}>
+                          <AttachmentTypeIcon name={att.name} />
+                        </span>
+                        <span className="ai-attach-file__name">{att.name}</span>
+                      </span>
+                    )
+                  )}
+                </div>
+              )}
+              {message.content && (
+                <div className="ai-msg__content">{renderMessageText(message.content)}</div>
+              )}
             </div>
-          </div>
-        )}
+          ) : (
+            <div key={message.id} className="ai-msg ai-msg--assistant">
+              {message.status && !message.content && (
+                <div className="ai-status" aria-live="polite">
+                  <span className="ai-status__shimmer">{message.status}</span>
+                  <span className="ai-status__dots">
+                    <span className="ai-typing__dot" />
+                    <span className="ai-typing__dot" />
+                    <span className="ai-typing__dot" />
+                  </span>
+                </div>
+              )}
+
+              {message.content && (
+                <div className="ai-msg__content">
+                  {renderMessageText(message.content)}
+                  {message.streaming && <span className="ai-caret" aria-hidden="true" />}
+                </div>
+              )}
 
+              {!message.streaming && message.content.trim().length > 0 && (
+                <div className="ai-msg__actions">
+                  <button
+                    className="ai-msg-action"
+                    onClick={() => void handleCopy(message.id, message.content)}
+                    aria-label="Copy response"
+                    title={copiedId === message.id ? "Copied" : "Copy"}
+                    type="button"
+                  >
+                    {copiedId === message.id ? <CheckIcon /> : <CopyIcon />}
+                  </button>
+                  <button
+                    className="ai-msg-action"
+                    data-active={speakingId === message.id}
+                    onClick={() => handleSpeak(message.id, message.content)}
+                    aria-label={speakingId === message.id ? "Stop reading" : "Read aloud"}
+                    title={speakingId === message.id ? "Stop" : "Read aloud"}
+                    type="button"
+                  >
+                    {speakingId === message.id ? <StopIcon /> : <SpeakerIcon />}
+                  </button>
+                </div>
+              )}
+            </div>
+          )
+        )}
         <div ref={chatEndRef} />
       </div>
 
-      {messages.length === 0 && !loading && (
-        <div
-          className="ai-sidebar__suggestions"
-          role="group"
-          aria-label="Suggested prompts"
-        >
-          {SUGGESTION_CHIPS.map((chip) => (
-            <button
-              key={chip}
-              className="ai-suggestion"
-              onClick={() => void handleSend(chip)}
-              type="button"
-            >
-              {chip}
-            </button>
-          ))}
-        </div>
-      )}
-
       <div className="ai-sidebar__composer-wrap">
+        {attachments.length > 0 && (
+          <div className="ai-composer__chips" aria-label="Attachments">
+            {attachments.map((att) =>
+              att.kind === "image" && att.dataUrl ? (
+                // Compact thumbnail so the four captured views fit on one row.
+                <span key={att.id} className="ai-thumb-chip" title={`${att.name} — click to enlarge`}>
+                  <img
+                    className="ai-thumb-chip__img"
+                    src={att.dataUrl}
+                    alt={att.name}
+                    onClick={() => setLightboxUrl(att.dataUrl ?? null)}
+                  />
+                  <button
+                    className="ai-thumb-chip__remove"
+                    onClick={() => removeAttachment(att.id)}
+                    aria-label={`Remove ${att.name}`}
+                    type="button"
+                  >
+                    <CloseIcon />
+                  </button>
+                </span>
+              ) : (
+                <span key={att.id} className="ai-chip" title={att.name}>
+                  <span className="ai-chip__type" data-type={fileTypeOf(att.name)}>
+                    <AttachmentTypeIcon name={att.name} />
+                  </span>
+                  <span className="ai-chip__label">{att.name}</span>
+                  <button
+                    className="ai-chip__remove"
+                    onClick={() => removeAttachment(att.id)}
+                    aria-label={`Remove ${att.name}`}
+                    type="button"
+                  >
+                    <CloseIcon />
+                  </button>
+                </span>
+              )
+            )}
+          </div>
+        )}
+
         <div className="ai-composer">
           <textarea
             ref={textareaRef}
@@ -573,108 +1068,145 @@ export default function AISidebar({
             onChange={handleInput}
             onKeyDown={handleKeyDown}
             placeholder="Ask about this scan…"
-            disabled={loading}
             aria-label="Message BodyMaps AI"
           />
 
           <div className="ai-composer__footer">
-            <div
-              ref={modelPickerRef}
-              className="ai-model-picker"
-            >
-              {modelMenuOpen && (
-                <div
-                  className="ai-model-menu"
-                  role="menu"
-                  aria-label="Choose an Ollama model"
+            <div className="ai-composer__tools">
+              <input
+                ref={fileInputRef}
+                type="file"
+                multiple
+                accept="image/*,.pdf,.nii,.nii.gz,.dcm"
+                className="ai-hidden-file"
+                onChange={handleFilePick}
+                aria-hidden="true"
+                tabIndex={-1}
+              />
+              <button
+                className="ai-tool-btn"
+                onClick={() => fileInputRef.current?.click()}
+                disabled={loading}
+                aria-label="Attach a file"
+                title="Attach image, PDF, or scan"
+                type="button"
+              >
+                <PlusIcon />
+              </button>
+              {captureViewport && (
+                <button
+                  className="ai-tool-btn"
+                  data-active={attachments.some((att) => att.source === "screenshot")}
+                  onClick={() => void handleCapture()}
+                  disabled={loading || capturing}
+                  aria-label={
+                    attachments.some((att) => att.source === "screenshot")
+                      ? "Remove the captured CT views"
+                      : "Attach screenshots of the four CT views"
+                  }
+                  title={
+                    attachments.some((att) => att.source === "screenshot")
+                      ? "Remove the captured views"
+                      : "Capture the four CT views"
+                  }
+                  type="button"
                 >
-                  <div className="ai-model-menu__heading">
-                    Local model
-                  </div>
-
-                  {models.length > 0 ? (
-                    <>
-                      <button
-                        className="ai-model-menu__item"
-                        data-selected={!selectedModel}
-                        onClick={() => selectModel("")}
-                        role="menuitemradio"
-                        aria-checked={!selectedModel}
-                        type="button"
-                      >
-                        <span>
-                          <strong>Automatic</strong>
-                          <small>Use the configured local default</small>
-                        </span>
-                        {!selectedModel ? <CheckIcon /> : null}
-                      </button>
+                  <CameraIcon />
+                </button>
+              )}
+            </div>
 
-                      {models.map((model) => (
+            <div className="ai-composer__right">
+              <div ref={modelPickerRef} className="ai-model-picker">
+                {modelMenuOpen && (
+                  <div className="ai-model-menu ai-model-menu--right" role="menu" aria-label="Choose an Ollama model">
+                    <div className="ai-model-menu__heading">Local model</div>
+                    {models.length > 0 ? (
+                      models.map((model) => (
                         <button
                           key={model.name}
                           className="ai-model-menu__item"
-                          data-selected={
-                            selectedModel === model.name
-                          }
+                          data-selected={selectedModel === model.name}
                           onClick={() => selectModel(model.name)}
                           role="menuitemradio"
-                          aria-checked={
-                            selectedModel === model.name
-                          }
+                          aria-checked={selectedModel === model.name}
                           type="button"
                         >
-                          <span>
-                            <strong>{model.name}</strong>
-                            <small>Installed in Ollama</small>
-                          </span>
-                          {selectedModel === model.name ? (
-                            <CheckIcon />
-                          ) : null}
+                          <strong>{model.name}</strong>
+                          {selectedModel === model.name ? <CheckIcon /> : null}
                         </button>
-                      ))}
-                    </>
-                  ) : (
-                    <div className="ai-model-menu__empty">
-                      No Ollama models available
-                    </div>
-                  )}
-                </div>
-              )}
+                      ))
+                    ) : (
+                      <div className="ai-model-menu__empty">No Ollama models available</div>
+                    )}
+                  </div>
+                )}
+                <button
+                  className="ai-model-picker__button"
+                  data-state={modelState}
+                  onClick={() => setModelMenuOpen((current) => !current)}
+                  disabled={modelState === "loading"}
+                  aria-haspopup="menu"
+                  aria-expanded={modelMenuOpen}
+                  type="button"
+                >
+                  <span className="ai-model-picker__dot" aria-hidden="true" />
+                  <span className="ai-model-picker__text">{modelLabel}</span>
+                  <ChevronIcon />
+                </button>
+              </div>
 
-              <button
-                className="ai-model-picker__button"
-                data-state={modelState}
-                onClick={() =>
-                  setModelMenuOpen((current) => !current)
-                }
-                disabled={modelState === "loading"}
-                aria-haspopup="menu"
-                aria-expanded={modelMenuOpen}
-                type="button"
-              >
-                <span
-                  className="ai-model-picker__dot"
-                  aria-hidden="true"
-                />
-                <span className="ai-model-picker__text">
-                  {modelLabel}
-                </span>
-                <ChevronIcon />
-              </button>
+              {loading ? (
+                <button
+                  className="ai-composer__send ai-composer__send--stop"
+                  onClick={handleStop}
+                  aria-label="Stop generating"
+                  title="Stop"
+                  type="button"
+                >
+                  <span className="ai-stop-square" aria-hidden="true" />
+                </button>
+              ) : (
+                <button
+                  className="ai-composer__send"
+                  onClick={() => void handleSend()}
+                  disabled={!canSend}
+                  aria-label="Send message"
+                  type="button"
+                >
+                  <SendIcon />
+                </button>
+              )}
             </div>
+          </div>
+        </div>
+      </div>
 
+      {/* Rendered through a portal to <body> so it fills the WHOLE screen. If it
+          lived inside .ai-sidebar, that panel's backdrop-filter would make it the
+          containing block for this position:fixed overlay and clip it to the
+          sidebar. The portal escapes that. */}
+      {lightboxUrl &&
+        typeof document !== "undefined" &&
+        createPortal(
+          <div
+            className="ai-lightbox"
+            onClick={() => setLightboxUrl(null)}
+            role="dialog"
+            aria-label="Enlarged image"
+          >
+            <img className="ai-lightbox__img" src={lightboxUrl} alt="Enlarged attachment" />
             <button
-              className="ai-composer__send"
-              onClick={() => void handleSend()}
-              disabled={loading || !input.trim()}
-              aria-label="Send message"
+              className="ai-lightbox__close"
+              onClick={() => setLightboxUrl(null)}
+              aria-label="Close"
               type="button"
             >
-              <SendIcon />
+              <CloseIcon />
             </button>
-          </div>
-        </div>
-      </div>
+          </div>,
+          document.body
+        )}
     </aside>
   );
 }
diff --git a/PanTS-Demo/src/components/AIAssistant/types.ts b/PanTS-Demo/src/components/AIAssistant/types.ts
index 69b1330..f8279f9 100644
--- a/PanTS-Demo/src/components/AIAssistant/types.ts
+++ b/PanTS-Demo/src/components/AIAssistant/types.ts
@@ -20,12 +20,34 @@ export type AIAction =
 
 export type ChatRole = "user" | "assistant" | "system";
 
+export type AttachmentKind = "image" | "file";
+
+export interface ChatAttachment {
+  id: string;
+  name: string;
+  kind: AttachmentKind;
+  /** Present for images: a data: URL used both for preview and for the model. */
+  dataUrl?: string;
+  /** Optional short label, e.g. the viewport a screenshot came from. */
+  label?: string;
+  /** Where the attachment came from — screenshots are added/removed as a set. */
+  source?: "screenshot" | "upload";
+}
+
 export interface ChatMessage {
   id: string;
   role: ChatRole;
   content: string;
   timestamp: number;
   meta?: string;
+  /** Assistant private reasoning, streamed live and shown in a muted block. */
+  thinking?: string;
+  /** Current progress stage shown while the answer is still forming. */
+  status?: string;
+  /** True while tokens are still arriving for this message. */
+  streaming?: boolean;
+  /** Images / files the user attached to this turn. */
+  attachments?: ChatAttachment[];
 }
 
 export interface ViewerStateSnapshot {
@@ -85,6 +107,11 @@ export interface ViewerActions {
   getSmallestStructure: () => Promise<string>;
 }
 
+export interface ViewportCapture {
+  name: string;
+  dataUrl: string;
+}
+
 export interface AISidebarProps {
   open: boolean;
   onClose: () => void;
@@ -96,4 +123,12 @@ export interface AISidebarProps {
   organReferences?: OrganReferenceSnapshot[];
   demographics?: DemographicsSnapshot | null;
   actions: ViewerActions;
+  /** Captures the current CT viewports (axial/sagittal/coronal/3D) as PNGs. */
+  captureViewport?: () => Promise<ViewportCapture[]>;
+  /** Color→organ legend for the visible masks, sent with screenshots. */
+  getMaskLegend?: () => { organ: string; color: string }[];
+  /** Live drag-resize: called with the pointer's clientX while dragging. */
+  onResize?: (clientX: number) => void;
+  /** Called when the resize drag ends, to persist the final width. */
+  onResizeEnd?: () => void;
 }
diff --git a/PanTS-Demo/src/components/MeshViewer.tsx b/PanTS-Demo/src/components/MeshViewer.tsx
index 2fa09e3..dcdfb07 100644
--- a/PanTS-Demo/src/components/MeshViewer.tsx
+++ b/PanTS-Demo/src/components/MeshViewer.tsx
@@ -70,7 +70,10 @@ export function SegmentationMeshViewer({ caseId, checkState, loading, opacity, c
   return (
     <div style={{ display: "flex", width: "100%", height: "100%" }}>
       <main style={{ flex: 1, minWidth: 0 }}>
-        <Canvas camera={{ position: [0, 250, 650], fov: 45, near: 0.1, far: 5000 }}>
+        <Canvas
+          camera={{ position: [0, 250, 650], fov: 45, near: 0.1, far: 5000 }}
+          gl={{ preserveDrawingBuffer: true }}
+        >
           <color attach="background" args={["#050505"]} />
           <ambientLight intensity={0.7} />
           <directionalLight position={[300, 500, 300]} intensity={1.2} />
diff --git a/PanTS-Demo/src/routes/VisualizationPage.css b/PanTS-Demo/src/routes/VisualizationPage.css
index 7425202..d609ec7 100644
--- a/PanTS-Demo/src/routes/VisualizationPage.css
+++ b/PanTS-Demo/src/routes/VisualizationPage.css
@@ -4,6 +4,27 @@
   grid-template-rows: 100vh;
   background-color: #08090b;
   color: white;
+  /* Width reserved for the BodyMaps AI sidebar. Shared by the sidebar itself
+     (src/components/AIAssistant/AISidebar.css) and by the content shift below,
+     so the CT views sit flush against the panel with no overlap. */
+  --vp-ai-width: 400px;
+}
+
+/* When the AI sidebar is open the page container shrinks (see the inline width
+   in VisualizationPage.tsx); the fixed, viewport-width bottom bar must shrink
+   with it so it doesn't slide under the panel. */
+.VisualizationPage.ai-panel-open .checkbox-bottom-bar {
+  width: calc(100vw - var(--vp-ai-width, 400px));
+}
+
+@media (max-width: 899px) {
+  /* On narrow screens the sidebar covers the full width, so no content shift. */
+  .VisualizationPage.ai-panel-open {
+    width: 100vw !important;
+  }
+  .VisualizationPage.ai-panel-open .checkbox-bottom-bar {
+    width: 100vw;
+  }
 }
 
 .sidebar {
@@ -1344,12 +1365,6 @@
   font-size: 11px;
   color: var(--vp-text-dim);
 }
-/* Dotted-underline affordance for a stat label with a hover explanation (e.g. Kurtosis) —
-   makes the tooltip discoverable instead of relying on users guessing to hover plain text. */
-.vp-stats__tooltip-label {
-  cursor: help;
-  border-bottom: 1px dotted var(--vp-text-faint);
-}
 
 /* ---- Case metadata panel — shares the .vp-stats dock shell (right of the stage) ---- */
 .vp-meta__list {
diff --git a/PanTS-Demo/src/routes/VisualizationPage.tsx b/PanTS-Demo/src/routes/VisualizationPage.tsx
index 595550e..193a80e 100644
--- a/PanTS-Demo/src/routes/VisualizationPage.tsx
+++ b/PanTS-Demo/src/routes/VisualizationPage.tsx
@@ -128,7 +128,6 @@ import {
 import {
     computeStatRows,
     downloadStats,
-    KURTOSIS_TOOLTIP,
     summarizeOutOfRange,
     type OrganMetric,
 } from "../helpers/organStatsExport";
@@ -238,6 +237,37 @@ const resolveOrganLabel = (idx: number): string | undefined => {
     return getCustomSegmentLabels()[idx];
 };
 
+// Map an RGB triple to a plain color name so the AI can identify each
+// segmentation-mask color by name (paired with the mask legend it receives).
+const _COLOR_NAMES: { name: string; rgb: [number, number, number] }[] = [
+	{ name: "red", rgb: [220, 30, 30] },
+	{ name: "brownish red", rgb: [150, 40, 30] },
+	{ name: "orange", rgb: [255, 140, 0] },
+	{ name: "yellow", rgb: [230, 210, 60] },
+	{ name: "green", rgb: [40, 170, 70] },
+	{ name: "teal", rgb: [40, 180, 170] },
+	{ name: "light blue", rgb: [120, 190, 235] },
+	{ name: "blue", rgb: [50, 110, 220] },
+	{ name: "purple", rgb: [140, 60, 200] },
+	{ name: "pink", rgb: [235, 110, 175] },
+	{ name: "magenta", rgb: [220, 60, 180] },
+	{ name: "gray", rgb: [200, 200, 200] },
+	{ name: "white", rgb: [245, 245, 245] },
+];
+
+function rgbToColorName(r: number, g: number, b: number): string {
+	let best = _COLOR_NAMES[0];
+	let bestDist = Infinity;
+	for (const c of _COLOR_NAMES) {
+		const d = (c.rgb[0] - r) ** 2 + (c.rgb[1] - g) ** 2 + (c.rgb[2] - b) ** 2;
+		if (d < bestDist) {
+			bestDist = d;
+			best = c;
+		}
+	}
+	return best.name;
+}
+
 const CT_PRESETS = [
 	{ name: "Soft Tissue", width: 400, center: 40 },
 	{ name: "Bone", width: 1800, center: 400 },
@@ -440,6 +470,11 @@ function VisualizationPage() {
 	const [showReportScreen, setShowReportScreen] = useState(false);
 	const [showStats, setShowStats] = useState(false);
 	const [showAISidebar, setShowAISidebar] = useState(false);
+	// Width (px) of the AI sidebar; drag-resizable from its left edge. Both the
+	// sidebar and the content shift read this via the --vp-ai-width CSS var.
+	const [aiWidth, setAiWidth] = useState(400);
+	const aiWidthRef = useRef(400);
+	const vpRootRef = useRef<HTMLDivElement>(null);
 	const [organStats, setOrganStats] = useState<OrganStat[] | null>(null);
 	const [statsLoading, setStatsLoading] = useState(false);
 	const [statsError, setStatsError] = useState(false);
@@ -649,6 +684,75 @@ function VisualizationPage() {
 		}
 	}, [caseId]);
 
+	// Downscale a screenshot so the vision model gets a small, fast-to-process
+	// image (full-res panes make local vision models slow and prone to timeout).
+	const downscaleDataUrl = (dataUrl: string, maxDim = 768): Promise<string> =>
+		new Promise((resolve) => {
+			const img = new Image();
+			img.onload = () => {
+				const scale = Math.min(1, maxDim / Math.max(img.width, img.height));
+				if (scale >= 1) return resolve(dataUrl);
+				const c = document.createElement("canvas");
+				c.width = Math.round(img.width * scale);
+				c.height = Math.round(img.height * scale);
+				const ctx = c.getContext("2d");
+				if (!ctx) return resolve(dataUrl);
+				ctx.drawImage(img, 0, 0, c.width, c.height);
+				resolve(c.toDataURL("image/jpeg", 0.85));
+			};
+			img.onerror = () => resolve(dataUrl);
+			img.src = dataUrl;
+		});
+
+	// Capture for the AI assistant: the three MPR panes (via the shared helper)
+	// plus the 3D pane's WebGL canvas — the four views the user sees in the 2×2
+	// grid. The segmentation masks are left VISIBLE so the model can identify
+	// each organ by its color (paired with the mask legend). Images are
+	// downscaled before returning so the vision model responds quickly.
+	const captureAllViews = useCallback(async () => {
+		const shots: { name: string; dataUrl: string }[] = await captureViewportImages();
+		try {
+			const pane = document.querySelector<HTMLElement>(".render");
+			const canvas = pane?.querySelector<HTMLCanvasElement>("canvas");
+			if (canvas && canvas.width && pane && pane.offsetParent !== null) {
+				const url = canvas.toDataURL("image/png");
+				if (url && url.length > 128) shots.push({ name: "3d", dataUrl: url });
+			}
+		} catch (error) {
+			console.warn("[BodyMaps AI] 3D capture skipped", error);
+		}
+		// Downscale all shots for fast vision inference.
+		return Promise.all(
+			shots.map(async (s) => ({ name: s.name, dataUrl: await downscaleDataUrl(s.dataUrl) }))
+		);
+	}, []);
+
+	// Color → organ legend for the currently visible masks, so the vision model
+	// can name each colored region correctly instead of guessing.
+	const getMaskLegend = useCallback((): { organ: string; color: string }[] => {
+		const legend: { organ: string; color: string }[] = [];
+		for (const item of checkBoxData) {
+			if (!checkState[item.id]) continue;
+			const rgb = labelColorMap[item.id] ?? segmentation_category_colors[item.id];
+			if (!rgb) continue;
+			legend.push({ organ: item.label, color: rgbToColorName(rgb[0], rgb[1], rgb[2]) });
+		}
+		return legend;
+	}, [checkBoxData, checkState, labelColorMap]);
+
+	// Live drag-resize of the AI panel. During the drag we set the CSS var
+	// directly on the page root (cheap, no React re-render) so the sidebar and
+	// the CT views resize smoothly; on release we persist the width to state.
+	const applyAiWidth = useCallback((clientX: number) => {
+		const w = Math.min(760, Math.max(320, window.innerWidth - clientX));
+		aiWidthRef.current = w;
+		vpRootRef.current?.style.setProperty("--vp-ai-width", `${w}px`);
+	}, []);
+
+	const commitAiWidth = useCallback(() => {
+		setAiWidth(aiWidthRef.current);
+	}, []);
+
 	const startReadingSession = async () => {
 		if (sessionRef.current || sessionStarting) return;
 		setSessionStarting(true);
@@ -1732,14 +1836,21 @@ const aiAvailableOrgans = useMemo(() => {
 
 	return (
 		<div
+			ref={vpRootRef}
 			className={`VisualizationPage${showAISidebar ? " ai-panel-open" : ""}`}
 			style={{
 				display: "flex",
 				overflow: "hidden",
 				flexDirection: "column",
 				height: "100vh",
-				width: "100vw",
-			}}>
+				["--vp-ai-width" as string]: `${aiWidth}px`,
+				// When the AI sidebar opens, shrink the app to the left of it so the
+				// CT views reflow beside the panel instead of being covered by it
+				// (the fixed sidebar occupies --vp-ai-width on the right). The
+				// showAISidebar resize effect re-fits the viewports to the new width.
+				width: showAISidebar ? "calc(100vw - var(--vp-ai-width, 400px))" : "100vw",
+				transition: "width 180ms ease",
+			} as React.CSSProperties}>
 		
 			{/* ---- Top toolbar (PYCAD-style). Lives in normal flow, so it sits ABOVE the
 			     viewports and never overlays them. Shown/hidden by the gear button. ---- */}
@@ -2904,9 +3015,7 @@ const aiAvailableOrgans = useMemo(() => {
 														<span>{fmtStat(r.skewness, 2)}</span>
 													</div>
 													<div className="vp-stats__detail-item">
-														<span className="vp-stats__tooltip-label" title={KURTOSIS_TOOLTIP}>
-														Kurtosis
-													</span>
+														<span>Kurtosis</span>
 														<span>{fmtStat(r.kurtosis, 2)}</span>
 													</div>
 													<div className="vp-stats__detail-item">
@@ -3025,6 +3134,10 @@ const aiAvailableOrgans = useMemo(() => {
 				organMetrics={organStats ?? []}
 				demographics={demographics}
 				actions={aiActions}
+				captureViewport={captureAllViews}
+				getMaskLegend={getMaskLegend}
+				onResize={applyAiWidth}
+				onResizeEnd={commitAiWidth}
 			/>
 			</div>
 
diff --git a/flask-server/.env.example b/flask-server/.env.example
index e884c9f..78c1cf7 100644
--- a/flask-server/.env.example
+++ b/flask-server/.env.example
@@ -7,9 +7,14 @@ USE_SSL=false
 
 # --- PanTS dataset (primary) ---
 # Folder that contains metadata.xlsx + image_only/ + mask_only/.
-PANTS_PATH=/mnt/bodymaps/zzhou82/data/PanTS
+# OPTIONAL for local dev: leave it unset (or pointing at a folder that does not
+# exist) and the backend still boots — the case library/search will be empty,
+# but the AI assistant still answers organ-volume questions because the mask/CT
+# are pulled from the HuggingFace mirror (BodyMaps/iPanTSMini) on demand.
+# Set it to your real dataset folder to enable the full case library.
+# PANTS_PATH=C:/path/to/PanTS
 # Writable dir for precomputed PanTS low-res volumes (make_lowres.py output).
-PANTS_LOWRES_PATH=/home/visitor/pants_lowres
+# PANTS_LOWRES_PATH=/home/visitor/pants_lowres
 
 # --- CancerVerse dataset (second, CT-only for now) ---
 # Folder that contains the CV_########/ct.nii.gz cases. The metadata CSV lives
@@ -20,75 +25,39 @@ CANCERVERSE_PATH=/mnt/bodymaps/zzhou82/data/CancerVerse
 #   <CANCERVERSE_LOWRES_PATH>/image_only/CV_########/ct_lowres.nii.gz
 CANCERVERSE_LOWRES_PATH=/home/visitor/cancerverse_lowres
 
-# --- Database ---
-# Full SQLAlchemy URL for the app database (inference job state; accounts later).
-# Unset -> a local SQLite file at flask-server/pants-dev.db (fine for dev).
-#
-# PRODUCTION: point at an absolute path OUTSIDE the git working tree, on LOCAL
-# disk (SQLite's file locking is unreliable over NFS). Create the dir once:
-#   mkdir -p /home/visitor/pants-app-data
-# then set:
-#   DATABASE_URL=sqlite:////home/visitor/pants-app-data/pants.db
-# (note the four slashes: sqlite:/// + an absolute /home/... path)
-#
-# Run `alembic upgrade head` (from flask-server/) after setting this, and on
-# every deploy that adds a migration.
-# DATABASE_URL=sqlite:////home/visitor/pants-app-data/pants.db
-
-# --- Sessions ---
-# SESSIONS_DIR_PATH=sessions
-# PERMISSIONS_DIR=/home/visitor/data
-
-# --- Accounts / auth ---
-# Signs the Flask session cookie (Authlib stores the OAuth CSRF `state` there).
-# REQUIRED in production and must be stable across restarts — if unset, the app
-# generates a random key at boot and any in-flight OAuth login breaks on reload.
-# Generate one with:  python -c "import secrets; print(secrets.token_hex(32))"
-# SECRET_KEY=
-
-# Browsers that may call the API with credentials (comma-separated). Must be
-# exact origins — no wildcard, since auth rides in a cookie.
-# ALLOWED_ORIGINS=https://bodymaps.wse.jhu.edu
-
-# Send the session cookie only over HTTPS. Set true in production.
-# SESSION_COOKIE_SECURE=true
-
-# Trust X-Forwarded-Proto/Host from the reverse proxy. REQUIRED in production:
-# without it the OAuth redirect_uri is built as http:// and Google/GitHub reject
-# it as a mismatch. Leave unset in dev — nothing trusted sits in front of the
-# app there, and the headers are client-spoofable.
-# TRUST_PROXY=true
-
-# Where OAuth sends the browser back after sign-in (your frontend origin).
-# Defaults to http://localhost:5173 for dev.
-# FRONTEND_URL=https://bodymaps.wse.jhu.edu
-
-# The app's public origin, used to build the OAuth redirect_uri that providers
-# match as an exact string. REQUIRED in production: derived from the request it
-# would depend on the proxy chain reporting the scheme correctly, and an
-# http:// value makes every sign-in fail. Leave unset in dev.
-# PUBLIC_BASE_URL=https://bodymaps.wse.jhu.edu
-
-# --- OAuth providers (optional) ---
-# Leave unset to disable a provider; its button stays disabled in the UI and
-# /api/auth/oauth/providers reports it as unavailable.
-#
-# Google: console.cloud.google.com > APIs & Services > Credentials >
-#   Create OAuth client ID > Web application. Authorized redirect URI:
-#   https://<your-domain>/api/auth/oauth/google/callback
-# GOOGLE_CLIENT_ID=
-# GOOGLE_CLIENT_SECRET=
-#
-# GitHub: github.com/settings/developers > New OAuth App.
-#   Authorization callback URL:
-#   https://<your-domain>/api/auth/oauth/github/callback
-# GITHUB_CLIENT_ID=
-# GITHUB_CLIENT_SECRET=
-
-# --- Legacy Postgres vars (unused) ---
-# Nothing reads these anymore; superseded by DATABASE_URL. Kept commented so an
-# old .env doesn't look wrong. Delete once no server .env references them.
+# --- Database / sessions (fill in as needed) ---
 # DB_USER=
 # DB_PASS=
 # DB_HOST=
 # DB_NAME=
+# SESSIONS_DIR_PATH=sessions
+# PERMISSIONS_DIR=/home/visitor/data
+
+# --- BodyMaps AI assistant (local Ollama) ---
+# See src/components/AIAssistant/README_AI_MODEL_SETUP.md for full setup.
+OLLAMA_BASE_URL=http://127.0.0.1:11434
+# llama3.1 is the safe default: it never shows a chain-of-thought. qwen3:4b is
+# faster but only stays clean if your Ollama honors "/no_think" (recent Ollama);
+# on older Ollama, qwen3 leaks its reasoning, so prefer llama3.1 there.
+BODYMAPS_OLLAMA_MODEL=llama3.1:latest
+# Used automatically when a message includes images (screenshots / uploads).
+BODYMAPS_OLLAMA_VISION_MODEL=qwen3-vl:4b
+OLLAMA_LIST_TIMEOUT_SECONDS=5
+OLLAMA_CHAT_TIMEOUT_SECONDS=180
+# Only the CONNECT step is time-limited for streaming; the answer itself streams
+# with no read timeout, so a slow but working reply is never cut off.
+OLLAMA_CONNECT_TIMEOUT_SECONDS=20
+OLLAMA_KEEP_ALIVE=30m
+# Context window. NUM_PREDICT=-1 means "no token cap" — the model always
+# finishes its answer instead of being cut off mid-sentence. Brevity for simple
+# questions comes from the prompt, not from a cap.
+OLLAMA_NUM_CTX=8192
+OLLAMA_NUM_PREDICT=-1
+# Keep this false. With qwen3 it also sends "/no_think" so the model answers
+# directly instead of generating a long (slow) reasoning chain first.
+OLLAMA_THINK=false
+
+# --- AI on-demand data cache ---
+# Writable cache for the case mask/CT the AI downloads from HuggingFace when the
+# local dataset is absent (used to answer organ-volume questions). Temp dir by default.
+# AI_DATA_CACHE_PATH=/home/visitor/bodymaps_ai_cache
diff --git a/flask-server/api/api_blueprint.py b/flask-server/api/api_blueprint.py
index 51b2c95..0c13424 100644
--- a/flask-server/api/api_blueprint.py
+++ b/flask-server/api/api_blueprint.py
@@ -1,20 +1,20 @@
-from flask import Blueprint, send_file, make_response, request, jsonify, Response
+from flask import Blueprint, send_file, make_response, request, jsonify, Response, stream_with_context
 from werkzeug.utils import secure_filename
 from services.nifti_processor import NiftiProcessor
 from services.session_manager import SessionManager, generate_uuid
 from services.auto_segmentor import run_auto_segmentation, cancel_session, cancel_all_inference
-from services.mesh_generation import generate_mesh_manifest, generate_organ_glb_bytes
+from services.mesh_generation import generate_mesh_manifest, generate_organ_glb_bytes, LABELS as MESH_LABELS
 from services.inference_job_queue import InferenceJobQueue
 from services.intent_parser import parse_intent
 from services.ollama_client import (
     DEFAULT_OLLAMA_MODEL,
+    DEFAULT_OLLAMA_VISION_MODEL,
     OllamaUnavailable,
     chat_json,
+    chat_stream,
     list_ollama_models,
 )
 from services.segmentation_metrics import calculate_session_metrics
-from services import job_store
-from api.auth import current_user, require_auth
 from services.search_ranking import rank_quality_results
 from services.site_normalization import site_country_label, split_site_codes
 from models.application_session import ApplicationSession
@@ -34,6 +34,7 @@
 from sqlalchemy.orm import aliased
 import os
 import io
+import tempfile
 from dotenv import load_dotenv
 
 # Load environment variables
@@ -66,12 +67,6 @@
 # directory before it touches os.path; secure_filename is the barrier at each
 # path-construction site.
 from .path_safety import is_safe_id as _is_safe_id
-from .chunk_store import (
-    CHUNK_TTL_SECONDS,
-    first_missing_chunk,
-    received_chunks,
-    sweep_stale_uploads,
-)
 
 
 def _metadata_xlsx_path():
@@ -273,6 +268,11 @@ def get_image_preview(clabel_id):
     )
 
 
+# ---------------------------------------------------------------------------
+# 3D organ meshes (the "3D" viewer tab). Meshes are pre-baked into MESH_PATH by
+# preprocess_meshes.py; these endpoints serve them.
+# ---------------------------------------------------------------------------
+
 @api_blueprint.route("/cases/<case_id>/mesh-manifest")
 def get_mesh_manifest(case_id):
     if not _is_safe_id(case_id):
@@ -303,7 +303,7 @@ def get_mesh_file(display_id, filename):
 
     except Exception as e:
         return jsonify({"error": f"Error generating GLB: {str(e)}"}), 500
-        
+
 
     return response
 
@@ -400,6 +400,16 @@ def get_mask_data():
         return jsonify({"error": "Missing sessionKey"}), 400
 
     result = get_mask_data_internal(session_key)
+
+    # For numeric PanTS cases, fall back to the robust label-based computation
+    # (with HuggingFace download) when the local dataset path is unavailable,
+    # so organ statistics resolve even without a full local PanTS install.
+    if str(session_key).strip().isdigit():
+        if not isinstance(result, dict) or result.get("error") or not result.get("organ_metrics"):
+            robust = _ai_compute_organ_metrics_from_labels(str(session_key).strip())
+            if robust and robust.get("organ_metrics"):
+                result = robust
+
     return jsonify(result)
 
   
@@ -919,22 +929,73 @@ def download_segmentation_zip(id):
 
 import time
 
-# Inference-job state lives in the `job` table via services.job_store now, not
-# in-process. These wrappers keep the historical call sites working.
+inference_jobs = {}  # {session_id: {status, model, error, session_path, zip_path}}
+# Guards the read-modify-write in _set_inference_job: background segmentation
+# threads and request handlers touch inference_jobs concurrently, and the
+# get/update/set below is not atomic without a lock (updates would be lost).
+_inference_jobs_lock = threading.Lock()
+
+
+def _job_meta_path(session_id):
+    # secure_filename is the CodeQL-recognised path-injection barrier (see
+    # path_safety.py): session_id reaches the filesystem here, so sanitize it
+    # at the construction site. Real ids are UUIDs, which pass through intact.
+    return os.path.join(SESSIONS_DIR, secure_filename(session_id), "job.json")
+
+
+def _persist_inference_job(session_id, snapshot):
+    """Mirror a job's metadata to disk so status survives a gunicorn restart.
+
+    Best-effort and fully isolated in try/except: a disk failure here must
+    never break the request that triggered the status change. Atomic via
+    write-temp-then-rename so a crash mid-write can't leave a corrupt file.
+    """
+    try:
+        path = _job_meta_path(session_id)  # sanitized via secure_filename
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
+            json.dump(snapshot, f, default=str)
+        os.replace(tmp, path)
+    except Exception as e:
+        print(f"[job persist] {session_id}: {e}")
 
 
 def _set_inference_job(session_id, **kwargs):
-    job_store.upsert_job(session_id, **kwargs)
+    with _inference_jobs_lock:
+        current = inference_jobs.get(session_id, {})
+        current.update(kwargs)
+        inference_jobs[session_id] = current
+        snapshot = dict(current)
+    _persist_inference_job(session_id, snapshot)
 
 
 def _get_inference_job(session_id):
-    return job_store.get_job(session_id)
-
+    """Look up a job, falling back to its on-disk copy after a restart.
 
-def _job_status_of(session_id):
-    """Lowercased status for a session, or '' if unknown."""
-    job = job_store.get_job(session_id)
-    return (job.get("status") or "").lower() if job else ""
+    Returns None when the session is genuinely unknown. A job found only on
+    disk was started by a *previous* process (a job from this process would
+    still be in memory); if that disk copy is still "running" its worker
+    thread died with the old process, so we surface it as failed rather than
+    reporting a phantom "running" that would poll forever.
+    """
+    job = inference_jobs.get(session_id)
+    if job:
+        return job
+    try:
+        path = _job_meta_path(session_id)
+        if os.path.exists(path):
+            with open(path) as f:
+                disk = json.load(f)
+            if (disk.get("status") or "").lower() in ("running", "queued"):
+                disk["status"] = "failed"
+                disk["error"] = disk.get("error") or "Interrupted by server restart"
+            with _inference_jobs_lock:
+                inference_jobs.setdefault(session_id, disk)
+            return inference_jobs.get(session_id)
+    except Exception as e:
+        print(f"[job rehydrate] {session_id}: {e}")
+    return None
 
 
 def _uploaded_file_candidate(session_id, uploaded_filename):
@@ -948,15 +1009,9 @@ def _uploaded_file_candidate(session_id, uploaded_filename):
     return candidate if os.path.exists(candidate) else None
 
 
-def _start_auto_segmentation(session_id, model_name, ct_file=None, server_input_path=None, user_id=None):
+def _start_auto_segmentation(session_id, model_name, ct_file=None, server_input_path=None):
     if not _is_safe_id(session_id):
         return jsonify({"error": "Invalid session ID"}), 400
-    # Running inference requires an account; the endpoint's @require_auth
-    # guarantees a user, and we record ownership on the job.
-    if not user_id:
-        user_id = (current_user() or {}).get("id")
-    if not user_id:
-        return jsonify({"error": "Authentication required"}), 401
     session_path = os.path.join(SESSIONS_DIR, session_id)
     os.makedirs(session_path, exist_ok=True)
 
@@ -985,7 +1040,6 @@ def _start_auto_segmentation(session_id, model_name, ct_file=None, server_input_
     # job to "running" when it actually gets the GPU.
     _set_inference_job(
         session_id,
-        user_id=user_id,
         status="queued",
         model=model_name,
         error=None,
@@ -995,7 +1049,8 @@ def _start_auto_segmentation(session_id, model_name, ct_file=None, server_input_
     )
 
     def _job_status():
-        return _job_status_of(session_id)
+        job = inference_jobs.get(session_id) or {}
+        return (job.get("status") or "").lower()
 
     def do_segmentation_and_zip():
         def _on_gpu_slot():
@@ -1047,7 +1102,6 @@ def _on_gpu_slot():
     return jsonify({"message": "Segmentation started", "session_id": session_id}), 200
 
 @api_blueprint.route('/auto_segment/<session_id>', methods=['POST'])
-@require_auth
 def auto_segment(session_id):
 
     model_name = request.form.get("MODEL_NAME", None)
@@ -1068,7 +1122,6 @@ def auto_segment(session_id):
 
 @api_blueprint.route('/run-epai-inference', methods=['POST'])
 @api_blueprint.route('/run-inference', methods=['POST'])
-@require_auth
 def run_epai_inference():
     """
     Runs ePAI inference with either:
@@ -1500,53 +1553,6 @@ def get_session_reconstruction(session_id):
 CHUNK_DIR = "/tmp/uploads"  # Temporary folder for chunked uploads
 os.makedirs(CHUNK_DIR, exist_ok=True)
 
-# Chunks are only deleted by finalize-upload/finalize-dicom, so an upload the
-# user abandons (tab closed and never reopened) would sit in CHUNK_DIR forever.
-# Sweep opportunistically from the chunk endpoint rather than running a timer:
-# gunicorn runs a single worker (see deploy/systemd/pants-flask.service), the
-# work is a stat per dir, and the only moment stale chunks cost anything is
-# when someone is uploading again.
-_SWEEP_INTERVAL_SECONDS = 60 * 60
-_last_sweep_at = 0.0
-_sweep_lock = threading.Lock()
-
-
-def _maybe_sweep_chunk_dir():
-    """Reclaim abandoned upload dirs, at most once per _SWEEP_INTERVAL_SECONDS."""
-    global _last_sweep_at
-    now = time.time()
-    with _sweep_lock:
-        if now - _last_sweep_at < _SWEEP_INTERVAL_SECONDS:
-            return
-        _last_sweep_at = now
-    try:
-        removed = sweep_stale_uploads(CHUNK_DIR, CHUNK_TTL_SECONDS, now)
-        if removed:
-            print(f"🧹 Swept {len(removed)} abandoned upload(s): {', '.join(removed)}")
-    except Exception as e:
-        # Never fail a live upload because cleanup had a bad day.
-        print(f"[sweep] failed: {e}")
-
-
-@api_blueprint.route("/upload-status/<session_id>", methods=["GET"])
-def upload_status(session_id):
-    """What the server still holds for a chunked upload.
-
-    A client resuming after a tab close trusts this over its own cursor: the
-    chunks may have been swept (TTL) or lost with the staging disk, in which
-    case `next_chunk` comes back 0 and it re-sends from the start instead of
-    finalizing over gaps.
-    """
-    if not _is_safe_id(session_id):
-        return jsonify({"error": "Invalid session ID"}), 400
-    indices = received_chunks(CHUNK_DIR, session_id)
-    return jsonify({
-        "session_id": session_id,
-        "received": len(indices),
-        "next_chunk": first_missing_chunk(indices),
-    }), 200
-
-
 @api_blueprint.route("/upload-inference-chunk", methods=["POST"])
 def upload_inference_chunk():
     """
@@ -1573,8 +1579,6 @@ def upload_inference_chunk():
         if not str(chunk_index).isdigit():
             return jsonify({"error": "Invalid chunk index"}), 400
 
-        _maybe_sweep_chunk_dir()
-
         session_folder = os.path.join(CHUNK_DIR, session_id)
         os.makedirs(session_folder, exist_ok=True)
 
@@ -1766,7 +1770,10 @@ def finalize_dicom():
 @api_blueprint.route('/cancel-inference', methods=['POST'])
 def cancel_inference():
     cancel_all_inference()
-    job_store.fail_all_active(error='Cancelled by user')
+    # Snapshot: _set_inference_job mutates the dict while we iterate.
+    for session_id, job in list(inference_jobs.items()):
+        if job.get('status') == 'running':
+            _set_inference_job(session_id, status='failed', error='Cancelled by user')
     return jsonify({"message": "Inference cancelled"}), 200
 
 
@@ -2173,6 +2180,149 @@ def _ai_public_metric(entry):
     }
 
 
+# Writable cache + HuggingFace mirror for on-demand case data used by the AI
+# organ-measurement feature (mask + CT), when the local dataset is absent.
+_AI_HF_CACHE_ROOT = (
+    os.getenv("AI_DATA_CACHE_PATH")
+    or os.path.join(tempfile.gettempdir(), "bodymaps_ai_cache")
+)
+_AI_HF_BASE = "https://huggingface.co/datasets/BodyMaps/iPanTSMini/resolve/main"
+
+
+def _ai_pants_id_or_none(case_id):
+    """Sanitize a case id to a fixed 'PanTS_########' string, or None.
+
+    Requires the id to be purely numeric, then derives the folder name from the
+    integer value. This neutralizes any path-traversal payload (the value that
+    reaches os.path.join is fully controlled, never the raw user string), and is
+    the check CodeQL recognizes as sanitizing py/path-injection.
+    """
+    if not str(case_id).isdigit():
+        return None
+    return get_panTS_id(int(case_id))
+
+
+def _ai_download_case_file(pants_id, rel_path, filename):
+    """Download <rel_path>/<filename> for a case from the HuggingFace mirror
+    into the AI cache and return the local path, or None on failure. pants_id is
+    already sanitized by _ai_pants_id_or_none."""
+    cache_dir = os.path.join(_AI_HF_CACHE_ROOT, pants_id)
+    cached = os.path.join(cache_dir, filename)
+    if os.path.exists(cached):
+        return cached
+    try:
+        os.makedirs(cache_dir, exist_ok=True)
+        url = f"{_AI_HF_BASE}/{rel_path}/{pants_id}/{filename}?download=true"
+        print(f"[ai metrics] downloading {filename} for {pants_id} from HuggingFace...")
+        resp = requests.get(url, stream=True, timeout=120)
+        resp.raise_for_status()
+        tmp = cached + ".part"
+        with open(tmp, "wb") as handle:
+            for chunk in resp.iter_content(chunk_size=8192):
+                handle.write(chunk)
+        os.replace(tmp, cached)
+        return cached
+    except Exception as exc:
+        print(f"[ai metrics] download failed for {pants_id}/{filename}: {exc}")
+        return None
+
+
+def _ai_local_mask_path(case_id):
+    """On-disk combined_labels.nii.gz for a numeric PanTS id — local dataset,
+    then low-res mirror, then a cached HuggingFace download. None if absent."""
+    pants_id = _ai_pants_id_or_none(case_id)
+    if not pants_id:
+        return None
+
+    if Constants.PANTS_PATH:
+        local = os.path.join(Constants.PANTS_PATH, "mask_only", pants_id, "combined_labels.nii.gz")
+        if os.path.exists(local):
+            return local
+
+    lowres = os.path.join(LOWRES_ROOT, "mask_only", pants_id, "combined_labels_lowres.nii.gz")
+    if os.path.exists(lowres):
+        return lowres
+
+    return _ai_download_case_file(pants_id, "mask_only", "combined_labels.nii.gz")
+
+
+def _ai_local_image_path(case_id):
+    """On-disk ct.nii.gz for a numeric PanTS id — local dataset, then a cached
+    HuggingFace download. Used for mean-HU. None if absent."""
+    pants_id = _ai_pants_id_or_none(case_id)
+    if not pants_id:
+        return None
+
+    if Constants.PANTS_PATH:
+        local = os.path.join(Constants.PANTS_PATH, "image_only", pants_id, "ct.nii.gz")
+        if os.path.exists(local):
+            return local
+
+    return _ai_download_case_file(pants_id, "image_only", "ct.nii.gz")
+
+
+def _ai_compute_organ_metrics_from_labels(case_id):
+    """Robust organ metrics straight from combined_labels.nii.gz (+ ct.nii.gz).
+
+    This is the fallback that makes organ-volume questions work WITHOUT a full
+    local PanTS install: both files are pulled from the HuggingFace mirror when
+    missing. Volume = voxel count * (sx*sy*sz mm) / 1000 -> cm3. Uses the
+    mesh-generation label ids (1-indexed, liver = 14), which match
+    combined_labels.nii.gz. Returns {"organ_metrics": [...]} or None.
+    """
+    if not str(case_id).isdigit() or not MESH_LABELS:
+        return None
+
+    mask_path = _ai_local_mask_path(case_id)
+    if not mask_path:
+        return None
+
+    try:
+        mask_nii = nib.load(mask_path)
+        mask = np.rint(np.asanyarray(mask_nii.dataobj)).astype(np.int32)
+
+        zooms = mask_nii.header.get_zooms()[:3]
+        voxel_cm3 = float(np.prod([abs(float(z)) for z in zooms])) / 1000.0
+
+        ct = None
+        image_path = _ai_local_image_path(case_id)
+        if image_path:
+            try:
+                ct = np.asanyarray(nib.load(image_path).dataobj).astype(np.float32)
+                if ct.shape != mask.shape:
+                    slc = tuple(slice(0, min(a, b)) for a, b in zip(ct.shape, mask.shape))
+                    ct = ct[slc]
+                    mask = mask[slc]
+            except Exception as exc:
+                print(f"[ai metrics] CT load skipped: {exc}")
+                ct = None
+
+        metrics = []
+        for label_id, meta in MESH_LABELS.items():
+            organ_mask = mask == label_id
+            voxel_count = int(np.count_nonzero(organ_mask))
+            if voxel_count == 0:
+                continue
+            entry = {
+                "organ_name": meta["key"],
+                "volume_cm3": round(voxel_count * voxel_cm3, 2),
+                "voxel_count": voxel_count,
+            }
+            if ct is not None:
+                entry["mean_hu"] = round(float(np.mean(ct[organ_mask])), 1)
+            metrics.append(entry)
+
+        return {"organ_metrics": metrics}
+    except Exception as exc:
+        print(f"[ai metrics] label computation failed for {case_id}: {exc}")
+        return None
+
+
+# Computed metrics are static per case — cache them so repeat questions don't
+# re-download the NIfTI from HuggingFace or recompute every time (big latency win).
+_AI_METRICS_CACHE = {}
+
+
 def _ai_load_metrics(case_id, supplied_metrics):
     """
     Prefer server-computed segmentation metrics.
@@ -2184,10 +2334,20 @@ def _ai_load_metrics(case_id, supplied_metrics):
 
     identifier = str(case_id or "").strip()
 
+    if identifier and identifier in _AI_METRICS_CACHE:
+        return _AI_METRICS_CACHE[identifier]
+
     if identifier and _is_safe_id(identifier):
         try:
             if identifier.isdigit():
                 result = get_mask_data_internal(identifier)
+                # Fall back to the robust label-based computation (with HF
+                # download) when the local dataset path is unavailable, so
+                # organ-volume questions still resolve to real numbers.
+                if not isinstance(result, dict) or result.get("error") or not result.get("organ_metrics"):
+                    robust = _ai_compute_organ_metrics_from_labels(identifier)
+                    if robust and robust.get("organ_metrics"):
+                        result = robust
                 source = "server_mask_data"
             else:
                 result = calculate_session_metrics(
@@ -2207,6 +2367,7 @@ def _ai_load_metrics(case_id, supplied_metrics):
                     ]
 
                     if cleaned:
+                        _AI_METRICS_CACHE[identifier] = (cleaned, source)
                         return cleaned, source
 
         except Exception as error:
@@ -2246,6 +2407,76 @@ def _ai_metric_lookup(metrics, available_organs):
     return lookup
 
 
+def _ai_legend_answer(message, mask_legend):
+    """Deterministic answer to a 'which color is the <organ>?' question, built
+    straight from the mask color legend. Lets us answer color-identification
+    questions instantly and reliably without waiting on the vision model."""
+    if not mask_legend:
+        return None
+    norm = _ai_norm(message)
+
+    def _pretty(organ):
+        return str(organ).replace("_", " ")
+
+    matched = []
+    for entry in mask_legend:
+        organ = str(entry.get("organ") or "")
+        words = [w for w in _ai_norm(organ).split() if len(w) > 2]
+        if _ai_norm(organ) in norm or any(w in norm for w in words):
+            matched.append(entry)
+
+    picks = matched or mask_legend[:8]
+    parts = [
+        f"the {_pretty(e.get('organ'))} is shown in {e.get('color')}"
+        for e in picks
+        if e.get("organ") and e.get("color")
+    ]
+    if not parts:
+        return None
+    return "In the segmentation overlay, " + "; ".join(parts) + "."
+
+
+def _ai_strip_think(text):
+    """Remove any <think>...</think> reasoning blocks a model emits inline, so
+    only the actual answer is shown. Handles an unclosed trailing <think>."""
+    if not text or "<think>" not in text:
+        return text or ""
+    out = text
+    while "<think>" in out and "</think>" in out:
+        start = out.find("<think>")
+        end = out.find("</think>", start)
+        if end == -1:
+            break
+        out = out[:start] + out[end + len("</think>"):]
+    if "<think>" in out:  # unclosed block still streaming — drop the tail
+        out = out[:out.find("<think>")]
+    return out.replace("<think>", "").replace("</think>", "")
+
+
+def _ai_required_metric_facts(actions, metrics, available_organs):
+    """Exact measurement sentence(s) the reply MUST contain — one per
+    get_organ_metric action — so a request like "segment the liver and give
+    me its volume" always includes the real, dataset-derived number.
+    """
+    lookup = _ai_metric_lookup(metrics, available_organs)
+    facts = []
+    for action in actions or []:
+        if action.get("type") != "get_organ_metric":
+            continue
+        entry = lookup.get(_ai_norm(action.get("organ")))
+        if not entry:
+            continue
+        organ = _ai_display(action.get("organ"))
+        metric = action.get("metric") or "volume_cm3"
+        volume = entry.get("volume_cm3")
+        mean_hu = entry.get("mean_hu")
+        if metric in ("volume_cm3", "all") and _ai_metric_valid(volume):
+            facts.append(f"The segmented {organ} volume is **{float(volume):.2f} cm³**.")
+        if metric in ("mean_hu", "all") and (_ai_metric_valid(mean_hu) or mean_hu == 0):
+            facts.append(f"The segmented {organ} mean attenuation is **{float(mean_hu):.1f} HU**.")
+    return facts
+
+
 def _ai_resolve_organ(value, available_organs):
     norm = _ai_norm(value)
     if not norm:
@@ -3102,12 +3333,15 @@ def _ai_grounded_reply(
     if confirmation:
         return confirmation
 
-    return (
-        "I could not generate a complete response. Please verify that "
-        "Ollama is running and that the selected model is installed."
-    )
+    return "I couldn't get an answer just now — please try again in a moment."
 
 
+# ---------------------------------------------------------------------------
+# Hidden system prompt ("guided model output"). Kept inline so the backend has
+# no extra-file dependency to misplace. Edit this text to change how the
+# assistant behaves. The streaming endpoint reuses everything up to
+# "OUTPUT FORMAT" and swaps in a prose contract instead of the JSON one.
+# ---------------------------------------------------------------------------
 def _ai_system_prompt():
     return """
 You are BodyMaps AI, a capable and conversational assistant embedded in
@@ -3116,6 +3350,21 @@ def _ai_system_prompt():
 Your job is to answer the user's actual question. Do not assume that
 every question asks about the current patient.
 
+ANSWER STYLE (most important rule)
+Answer EVERY part of the question — if the user asks several things, address
+each one. Match depth to the question: a simple factual question gets a short,
+direct answer (1-3 sentences); a complex or clinical question gets a fuller,
+well-organized answer. Always complete your answer and finish every sentence;
+never stop mid-thought. Output ONLY the final answer — never your reasoning,
+planning, or thought process, and never begin with words like "Okay", "Let me",
+"First", "I need to", or "The user". Start directly with the answer.
+
+NEVER MENTION TECHNICAL / BACKEND DETAILS
+Never talk about missing files, empty metadata, unavailable datasets,
+downloads, servers, or why some data is or isn't present. If you lack case
+data, simply answer the general part of the question or ask the user for what
+you need — without ever explaining that data was missing.
+
 You operate in several modes.
 
 GENERAL EDUCATIONAL QUESTIONS
@@ -3145,6 +3394,23 @@ def _ai_system_prompt():
 
 Never invent a case-specific value. Use exact supplied values.
 
+ANSWERING VOLUME AND MEASUREMENT QUESTIONS
+The application computes organ measurements from the segmentation mask on
+the server (the same data behind the /mask-data endpoint): it counts the
+voxels carrying that organ's label and multiplies by the physical size of
+one voxel (x * y * z spacing in mm, from the NIfTI header) to get a volume
+in cubic centimeters (cm3 / cc). Mean HU is the average CT intensity inside
+the mask.
+
+When the user asks for an organ's volume or size and it is present in
+computed_organ_metrics or exact_answer_facts:
+- State the exact number, with units, verbatim (e.g. "1512.34 cm3").
+- Do NOT round differently, recompute, estimate, or invent a value.
+- If the organ is not in the supplied data, say the measurement is not
+  available for this case rather than guessing.
+Briefly noting how the number is derived (voxels x voxel volume) is welcome,
+but the number itself must come from the supplied data.
+
 CASE-SPECIFIC HEALTH QUESTIONS
 When the user asks questions such as:
 - Is this liver healthy?
@@ -3187,12 +3453,70 @@ def _ai_system_prompt():
 - General medical and imaging knowledge does not need to be present in
   the case metadata.
 - Patient-specific facts must come from supplied data.
-- If case measurements are unavailable, say which data is missing and
-  still answer the educational portion of the question.
+- If case measurements are unavailable, quietly answer the general/educational
+  part of the question, or ask the user for what's needed. Do NOT mention that
+  any data, file, or metadata was missing.
 - "Segment the liver" means display or isolate an existing segmentation.
   Do not claim a new segmentation model was run unless the backend
   actually reports that it ran.
 
+USING CASE METADATA AND REPORTS
+The PanTS dataset ships patient metadata (age, sex, BMI, height, weight)
+and, for some cases, a structured radiology report. When it is supplied,
+weave the relevant pieces into a case-specific answer - e.g. interpret an
+organ volume in the context of the patient's age and sex. Never print a
+value that was not supplied.
+
+ASKING FOR MORE INFORMATION
+If the question is under-specified or the data needed to answer it well is
+missing, ask one short, specific follow-up question instead of guessing -
+for example which organ the user means, or whether they want the measured
+volume or a general reference range.
+
+ADAPTING TO THE AUDIENCE
+Readers range from high-school students to practicing radiologists. Match
+the questioner's apparent level: define terms plainly for a beginner, and
+be concise and technical for an expert. Keep the default tone clear,
+friendly, and free of unnecessary jargon.
+
+CONTINUING THE CONVERSATION
+Always end your answer with ONE short, relevant follow-up question that invites
+the user to continue the conversation (e.g. offering to compare a value to a
+typical range, look at another structure, or explain a term). Keep it to a
+single line. The only exception is a pure viewer command ("liver isolated"),
+where a brief confirmation is enough.
+
+ASKING FOR THE INFORMATION YOU NEED
+When the data required to answer is missing, ask the user for exactly that,
+then answer once they provide it:
+- BMI needs height and weight (BMI = weight_kg / height_m^2). If they are not
+  in the case metadata, ask the user for their height and weight rather than
+  guessing.
+- A size or "is this normal" judgement is more meaningful with age and sex; if
+  those are missing from the metadata, ask for them.
+- If the user names an organ that isn't in this case's segmentation, say so and
+  ask whether they meant one of the available structures.
+
+EXPLAINING SCREENSHOTS AND IDENTIFYING ORGANS BY COLOR
+The user can attach screenshots captured directly from the CT viewer: the
+axial, sagittal, and coronal panes plus, if present, a 3D view. The
+semi-transparent colored shapes painted over the grayscale CT are segmentation
+masks - each color marks one organ. When "mask_color_legend" is provided, it
+maps each color to its organ (e.g. "brownish red" -> liver); USE THAT LEGEND to
+name organs by their color instead of guessing, and quote the legend color
+names when you point an organ out. The 3D image shows those same organs as
+reconstructed surfaces.
+Also explain, in plain English, the on-screen markings that are part of the
+tool and NOT anatomy:
+- The thin colored crosshair / reference lines are a navigation aid marking the
+  current slice position shared across the panes - not a finding, wire,
+  catheter, or fracture.
+- Corner letters (A/P/L/R/S/I) are orientation markers (anterior/posterior,
+  left/right, superior/inferior); a small bar is a scale reference; numbers in
+  a corner are the window width/level (display brightness/contrast).
+Describe what the underlying CT anatomy shows, keep it separate from these
+interface markings, and stay non-diagnostic when reading an image.
+
 OUTPUT FORMAT
 Return exactly one JSON object:
 
@@ -3502,6 +3826,374 @@ def ai_command():
             }
         ), 500
 
+
+def _ai_stream_system_prompt(has_images: bool) -> str:
+    """System prompt for the streaming endpoint.
+
+    Adapts the diagnostic-dialogue framework from the AMIE paper (Tu et al.,
+    Nature 2025, "Towards conversational diagnostic AI") into a single-pass
+    prompt: structured history-taking (ask for missing info), differential
+    reasoning, management/next-steps, escalation, and empathetic communication —
+    while keeping simple factual questions short. Kept focused (not a giant
+    JSON dump) so small local models answer instead of rambling; exact case
+    values are injected as a short "Facts:" block in the user message.
+    """
+    prompt = (
+        "You are BodyMaps AI, a knowledgeable, empathetic medical-imaging "
+        "assistant inside a CT scan viewer. Talk like a thoughtful clinician "
+        "having a natural conversation.\n\n"
+        "OUTPUT ONLY THE FINAL ANSWER. Never write your reasoning, planning, "
+        "analysis, or thought process. Do NOT think out loud. Do NOT begin with "
+        "words like 'Okay', 'Let me', 'First', 'I need to', 'The user', or 'So' "
+        "— start directly with the answer itself.\n\n"
+        "HOW TO ANSWER\n"
+        "- Write ONLY the answer itself, as natural flowing prose. Never "
+        "describe what you are about to do, never number steps or label "
+        "sections, and never say things like 'let me explain', 'first', or 'as a "
+        "follow-up' — just say it.\n"
+        "- Be concise. Most answers are 1-3 sentences, a short paragraph at "
+        "most. Only a genuinely complex clinical question needs more, and even "
+        "then keep it tight.\n"
+        "- Answer every part of the question, and always finish completely — "
+        "never stop mid-sentence.\n\n"
+        "THIS APP ALREADY HAS THE DATA. The scan is measured for you — organ "
+        "volumes, mean HU, and any percentiles are in the 'Facts:' block. Your "
+        "value is INTERPRETING those numbers, not collecting them.\n\n"
+        "CLINICAL / HEALTH QUESTIONS (symptoms, 'could this be...', 'is this "
+        "normal', diagnosis, management): before answering, silently work out "
+        "what the numbers show, the most likely explanations, what information "
+        "is still missing, and whether anything is urgent — then give a short, "
+        "warm paragraph that states what the values suggest, the leading "
+        "possibilities and what would tell them apart, and sensible next steps "
+        "or when to seek in-person care. Clearly flag urgency / escalation if "
+        "anything sounds serious. Stay educational and NON-DIAGNOSTIC; never "
+        "give a definitive diagnosis.\n\n"
+        "CITE THE NUMBER. Tie every case-specific claim to a value from the "
+        "Facts — name the volume, mean HU, or percentile you rely on (e.g. 'the "
+        "liver volume of 1512 cm3 is above the typical range'). Never state a "
+        "fact about this case that you cannot tie to a provided value; if a "
+        "value you need is not in the Facts, say what's missing and ask for it "
+        "rather than guessing.\n\n"
+        "END EACH REPLY with one natural follow-up question (its own sentence) "
+        "that invites the user to continue — phrased conversationally, with NO "
+        "lead-in label. If you are missing something you genuinely need, make "
+        "that the question (for example, BMI needs height and weight). A pure "
+        "viewer command just needs a short confirmation.\n\n"
+        "Use any values in the 'Facts:' block verbatim (with units). Never "
+        "invent patient values or history. Never mention missing data, files, "
+        "or technical details."
+    )
+    if has_images:
+        # HIDDEN PROMPT — SCREENSHOT ARTIFACTS (crosshairs + color segmentation).
+        # Tells the model how to read a captured CT screenshot: it WILL contain
+        # (1) semi-transparent colored segmentation masks and (2) thin crosshair
+        # reference lines. The model names organs by mask color (via the legend)
+        # and treats crosshairs as navigation, not anatomy.
+        prompt += (
+            "\n\nIMAGES\n"
+            "Screenshots of CT views are attached. They contain semi-transparent "
+            "COLORED SEGMENTATION MASKS (one color per organ) and thin CROSSHAIR "
+            "reference lines. Use the mask color list in the Facts to say which "
+            "color is which organ. The crosshair lines are just a navigation aid "
+            "marking the current slice — NOT anatomy, a wire, a catheter, or a "
+            "fracture. Describe the CT anatomy, keep it separate from these "
+            "overlays, and stay non-diagnostic."
+        )
+    return prompt
+
+
+@api_blueprint.route("/ai-command-stream", methods=["POST"])
+def ai_command_stream():
+    """Streaming sibling of /ai-command.
+
+    Emits newline-delimited JSON events so the browser can show the answer
+    forming in real time:
+      {"type":"status","text":...}      progress stage (shown while thinking)
+      {"type":"thinking","delta":...}   model private reasoning tokens
+      {"type":"reply","delta":...}      answer tokens as they arrive
+      {"type":"final","reply":...,"actions":[...],"source":...,"model":...}
+      {"type":"done"}
+      {"type":"error","message":...}
+    The "final" reply is authoritative — for case measurements it carries the
+    exact server-computed value, so the client should replace the streamed
+    text with it on arrival.
+    """
+    body = request.get_json(force=True, silent=True) or {}
+
+    message = str(body.get("message") or "").strip()
+
+    available_organs = body.get("available_organs") or []
+    if not isinstance(available_organs, list):
+        available_organs = []
+    available_organs = [
+        str(item).strip() for item in available_organs if str(item).strip()
+    ]
+
+    viewer_state = body.get("viewer_state") if isinstance(body.get("viewer_state"), dict) else {}
+    case_id = str(body.get("session_id") or body.get("case_id") or "").strip()
+
+    requested_model = body.get("model")
+    selected_model = (
+        requested_model.strip()
+        if isinstance(requested_model, str) and requested_model.strip()
+        else DEFAULT_OLLAMA_MODEL
+    )
+
+    # Normalize attached images to bare base64 (strip any data: URL prefix).
+    raw_images = body.get("images") if isinstance(body.get("images"), list) else []
+    images: list[str] = []
+    for item in raw_images:
+        if not isinstance(item, str) or not item.strip():
+            continue
+        value = item.strip()
+        if value.startswith("data:"):
+            comma = value.find(",")
+            if comma != -1:
+                value = value[comma + 1:]
+        images.append(value)
+
+    supplied_metrics = body.get("organ_metrics")
+    supplied_demographics = body.get("demographics")
+
+    # Color legend for the segmentation overlays in attached screenshots:
+    # [{"organ": "liver", "color": "brownish red"}, ...]. Lets the vision model
+    # map each colored region to the right organ instead of guessing.
+    raw_legend = body.get("mask_legend") if isinstance(body.get("mask_legend"), list) else []
+    mask_legend = []
+    for item in raw_legend:
+        if isinstance(item, dict):
+            organ = str(item.get("organ") or "").strip()
+            color = str(item.get("color") or "").strip()
+            if organ and color:
+                mask_legend.append({"organ": organ, "color": color})
+
+    # Recent turns for multi-turn continuity (role/content pairs, already
+    # trimmed client-side). Kept small and defensively normalized.
+    raw_conversation = body.get("conversation")
+    conversation = []
+    if isinstance(raw_conversation, list):
+        for turn in raw_conversation[-12:]:
+            if not isinstance(turn, dict):
+                continue
+            role = str(turn.get("role") or "").strip()
+            content = str(turn.get("content") or "").strip()
+            if role in {"user", "assistant"} and content:
+                conversation.append({"role": role, "content": content[:2000]})
+
+    def sse(event: dict) -> str:
+        return json.dumps(event, ensure_ascii=False) + "\n"
+
+    def generate():
+        if not message and not images:
+            yield sse({"type": "final", "reply": "Please type a question or viewer command.", "actions": [], "source": "validation"})
+            yield sse({"type": "done"})
+            return
+
+        try:
+            yield sse({"type": "status", "text": "Understanding your question"})
+
+            metadata = _ai_metadata(case_id, supplied_demographics)
+            references_case = _ai_has_case_reference(_ai_norm(message))
+
+            # Parse intent first (cheap, no I/O) so we can decide whether the
+            # question actually needs the (potentially slow) case metrics.
+            fallback = parse_intent(
+                message=message or "Describe what is shown.",
+                available_organs=available_organs,
+                viewer_state=viewer_state,
+                case_id=case_id or None,
+            )
+            fallback_actions = _ai_sanitize_actions(fallback.get("actions", []), available_organs)
+            question_mode = _ai_question_mode(message, fallback_actions)
+
+            # Only load organ metrics (which may download the NIfTI and compute)
+            # when the question is actually about this case. General questions
+            # like "what is BMI?" skip this entirely and answer immediately.
+            _organ_action_types = {
+                "get_organ_metric", "get_largest_structure", "get_smallest_structure",
+                "isolate_organs", "focus_organ", "show_organs",
+            }
+            needs_metrics = bool(case_id) and (
+                references_case
+                or question_mode in {"case_measurement", "case_metadata", "case_health_context"}
+                or any(a.get("type") in _organ_action_types for a in fallback_actions)
+            )
+
+            if needs_metrics:
+                yield sse({"type": "status", "text": "Measuring the segmentation for this case"})
+                metrics, metric_source = _ai_load_metrics(case_id, supplied_metrics)
+                for metric in metrics:
+                    organ_name = str(metric.get("organ_name") or "").strip()
+                    if organ_name and organ_name not in available_organs:
+                        available_organs.append(organ_name)
+                # Re-sanitize now that the organ catalog may have grown.
+                fallback_actions = _ai_sanitize_actions(fallback.get("actions", []), available_organs)
+            else:
+                metrics, metric_source = [], "skipped"
+
+            # Send the viewer actions early so the viewer reacts immediately
+            # (e.g. isolate the liver) while the text is still generating.
+            if fallback_actions:
+                yield sse({"type": "actions", "actions": fallback_actions})
+
+            exact_facts = _ai_case_facts(message, metrics, metadata) if references_case else []
+
+            # Exact measurement sentences that MUST appear when the user asked
+            # for an organ metric (guarantees the volume is always answered).
+            required_facts = _ai_required_metric_facts(fallback_actions, metrics, available_organs)
+            for fact in required_facts:
+                if fact not in exact_facts:
+                    exact_facts.append(fact)
+
+            # A clean, buttonless confirmation of any viewer action (never the
+            # rule parser's "click below ..." text, which has no button here).
+            action_confirmation = _ai_action_confirmation(fallback_actions)
+
+            # Fast path: "which color is the <organ>?" is answerable instantly
+            # and reliably from the mask legend — no (slow) vision call needed.
+            norm_msg = _ai_norm(message)
+            asks_color = "color" in norm_msg or "colour" in norm_msg
+            if images and mask_legend and asks_color:
+                legend_reply = _ai_legend_answer(message, mask_legend)
+                if legend_reply:
+                    yield sse({"type": "reply", "delta": legend_reply})
+                    yield sse({
+                        "type": "final", "reply": legend_reply,
+                        "actions": fallback_actions, "source": "legend",
+                        "model": None, "intent": "identify_color",
+                    })
+                    yield sse({"type": "done"})
+                    return
+
+            # Build a SHORT user prompt: the question + only the facts the model
+            # actually needs. (A giant JSON payload makes small models ramble.)
+            facts_lines = list(dict.fromkeys([f for f in (exact_facts + required_facts) if f]))
+            if images and mask_legend:
+                legend_str = ", ".join(
+                    f"{str(e['organ']).replace('_', ' ')}: {e['color']}" for e in mask_legend
+                )
+                facts_lines.append(f"Segmentation mask colors — {legend_str}.")
+
+            user_prompt = message or "Describe what is shown."
+            if conversation:
+                recent = conversation[-2:]
+                convo_str = "\n".join(
+                    f"{t['role']}: {t['content'][:200]}" for t in recent
+                )
+                user_prompt = f"Recent conversation:\n{convo_str}\n\nQuestion: {user_prompt}"
+            if facts_lines:
+                user_prompt += "\n\nFacts:\n" + "\n".join(f"- {f}" for f in facts_lines)
+        except Exception as error:
+            print("[ai_command_stream setup error]", type(error).__name__, str(error))
+            yield sse({"type": "error", "message": "An internal error occurred while preparing the answer."})
+            yield sse({"type": "done"})
+            return
+
+        # Stream the model answer.
+        vision_model = None
+        if images:
+            vision_model = (
+                DEFAULT_OLLAMA_VISION_MODEL
+                if DEFAULT_OLLAMA_VISION_MODEL
+                else selected_model
+            )
+
+        model_for_call = vision_model or selected_model
+        model_ok = False
+
+        yield sse({"type": "status", "text": "Composing the answer"})
+
+        raw_content = ""   # full model content so far (may contain <think> blocks)
+        emitted = ""       # cleaned text already sent to the client
+        try:
+            for kind, text in chat_stream(
+                model=model_for_call,
+                system_prompt=_ai_stream_system_prompt(bool(images)),
+                user_prompt=user_prompt,
+                images=images or None,
+            ):
+                if not text:
+                    continue
+                # Drop the model's private reasoning entirely — the user only
+                # wants the answer, not the "steps".
+                if kind == "thinking":
+                    continue
+                raw_content += text
+                cleaned = _ai_strip_think(raw_content)
+                if len(cleaned) > len(emitted):
+                    delta = cleaned[len(emitted):]
+                    emitted = cleaned
+                    model_ok = True
+                    yield sse({"type": "reply", "delta": delta})
+        except OllamaUnavailable as error:
+            print("[ai_command_stream] Ollama unavailable:", str(error))
+        except Exception as error:
+            print("[ai_command_stream] stream error:", type(error).__name__, str(error))
+
+        streamed_reply = _ai_strip_think(raw_content).strip()
+
+        if model_ok and streamed_reply:
+            # Trust the model's conversational answer: it was given the exact
+            # values and is instructed to end with a relevant follow-up
+            # question, so keep that text (grounding would strip the follow-up).
+            final_reply = streamed_reply
+
+            # Safety net: if the measured number was paraphrased away, append
+            # the exact fact so the real value is always present.
+            try:
+                for fact in exact_facts:
+                    numbers = [
+                        token.strip("*").rstrip(".,")
+                        for token in fact.replace(",", " ").split()
+                        if "." in token and any(ch.isdigit() for ch in token)
+                    ]
+                    if numbers and not any(num and num in final_reply for num in numbers):
+                        final_reply += "\n\n" + fact
+            except Exception as error:
+                print("[ai_command_stream fact-check]", type(error).__name__, str(error))
+        else:
+            # Model offline/empty -> build a clean deterministic reply. Order:
+            # image color legend, then viewer-action confirmation + measured
+            # value(s), then a short friendly message. Never the rule parser's
+            # "click below ..." text or a scary "verify Ollama" string.
+            parts = []
+            if images and mask_legend:
+                legend_reply = _ai_legend_answer(message, mask_legend)
+                if legend_reply:
+                    parts.append(legend_reply)
+            if action_confirmation:
+                parts.append(action_confirmation)
+            parts.extend(required_facts)
+            if parts:
+                final_reply = " ".join(parts)
+            else:
+                final_reply = (
+                    "I couldn't get an answer just now — please try again in a moment."
+                )
+
+        if not final_reply:
+            final_reply = (
+                "I could not generate a response. The local model may be "
+                "offline — viewer controls still work from the left panel."
+            )
+
+        yield sse({
+            "type": "final",
+            "reply": final_reply,
+            "actions": fallback_actions,
+            "source": "ollama" if model_ok else "rule_fallback",
+            "model": model_for_call if model_ok else None,
+            "intent": fallback.get("intent") or question_mode,
+        })
+        yield sse({"type": "done"})
+
+    return Response(
+        stream_with_context(generate()),
+        mimetype="application/x-ndjson",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
 # ---------------------------------------------------------------------------
 # Edited segmentation masks (viewer's Edit Masks panel).
 # Strictly additive and isolated: writes ONLY into {PANTS_PATH}/edited_masks/,
diff --git a/flask-server/api/utils.py b/flask-server/api/utils.py
index ba3028b..41661e9 100644
--- a/flask-server/api/utils.py
+++ b/flask-server/api/utils.py
@@ -1274,11 +1274,26 @@ def ensure_sort_cols(df: pd.DataFrame) -> pd.DataFrame:
     df["__complete"] = complete
     return df
 
-# load meta
-if not os.path.exists(META_FILE):
-    raise FileNotFoundError(f"metadata not found: {META_FILE}")
-DF_RAW = pd.read_excel(META_FILE)
-DF = _norm_cols(DF_RAW)
+# load meta — OPTIONAL in local dev. metadata.xlsx powers the case library and
+# search; without it those simply return nothing. The viewer (loads a case by
+# id) and the AI assistant (organ volumes come straight from the NIfTI masks /
+# HuggingFace) both still work, so a missing file must NOT crash the backend.
+if os.path.exists(META_FILE):
+    try:
+        DF_RAW = pd.read_excel(META_FILE)
+    except Exception as _meta_err:
+        print(f"[WARN] Could not read metadata {META_FILE}: {_meta_err} — case library will be empty.")
+        DF_RAW = pd.DataFrame()
+else:
+    print(f"[WARN] metadata not found: {META_FILE} — case library/search will be empty. "
+          "Set PANTS_PATH in flask-server/.env to your dataset to enable it.")
+    DF_RAW = pd.DataFrame()
+
+try:
+    DF = _norm_cols(DF_RAW)
+except Exception as _norm_err:
+    print(f"[WARN] metadata normalization failed: {_norm_err} — using empty catalog.")
+    DF = pd.DataFrame()
 
 # CancerVerse metadata (CT-only second dataset). Loaded through the SAME _norm_cols
 # so search/sort/row_to_item work unchanged. Optional: if the path/CSV is absent
diff --git a/flask-server/services/ollama_client.py b/flask-server/services/ollama_client.py
index d66d664..6be9508 100644
--- a/flask-server/services/ollama_client.py
+++ b/flask-server/services/ollama_client.py
@@ -13,9 +13,18 @@
     "http://localhost:11434",
 ).rstrip("/")
 
+# Default to llama3.1 — it is NOT a reasoning model, so it never leaks a
+# chain-of-thought "thinking" block into the answer. qwen3 is faster but only
+# stays clean when the local Ollama honors the /no_think switch (recent Ollama).
 DEFAULT_OLLAMA_MODEL = os.getenv(
     "BODYMAPS_OLLAMA_MODEL",
-    "llama3.1",
+    "llama3.1:latest",
+).strip()
+
+# Model used when the request carries images (screenshots / attached scans).
+DEFAULT_OLLAMA_VISION_MODEL = os.getenv(
+    "BODYMAPS_OLLAMA_VISION_MODEL",
+    "qwen3-vl:4b",
 ).strip()
 
 OLLAMA_LIST_TIMEOUT = float(
@@ -24,9 +33,32 @@
 
 # Local models can take longer than 30 seconds on the first request.
 OLLAMA_CHAT_TIMEOUT = float(
-    os.getenv("OLLAMA_CHAT_TIMEOUT_SECONDS", "120")
+    os.getenv("OLLAMA_CHAT_TIMEOUT_SECONDS", "180")
 )
 
+OLLAMA_KEEP_ALIVE = os.getenv("OLLAMA_KEEP_ALIVE", "30m").strip() or "30m"
+
+OLLAMA_NUM_CTX = int(os.getenv("OLLAMA_NUM_CTX", "8192"))
+
+# Ceiling on generated tokens. -1 means "no cap": the model generates until it
+# naturally finishes, so answers are never cut off mid-sentence. Brevity for
+# simple questions comes from the prompt, not from a low cap.
+OLLAMA_NUM_PREDICT = int(os.getenv("OLLAMA_NUM_PREDICT", "-1"))
+
+# Connect timeout for the streaming call. The READ timeout is intentionally
+# unlimited (see chat_stream) so a slow, still-working generation is never
+# disconnected before it finishes.
+OLLAMA_CONNECT_TIMEOUT = float(os.getenv("OLLAMA_CONNECT_TIMEOUT_SECONDS", "20"))
+
+# Ask the model to emit its private reasoning as a separate "thinking" stream
+# (supported by qwen3 / reasoning models). When false, only the answer streams.
+OLLAMA_THINK = os.getenv("OLLAMA_THINK", "false").strip().lower() in {
+    "1",
+    "true",
+    "yes",
+    "on",
+}
+
 
 class OllamaUnavailable(RuntimeError):
     """Raised when the local Ollama server cannot complete a request."""
@@ -174,10 +206,14 @@ def chat_json(
         else OLLAMA_CHAT_TIMEOUT
     )
 
+    json_user_prompt = user_prompt
+    if not OLLAMA_THINK and "qwen3" in selected_model.lower():
+        json_user_prompt = f"{json_user_prompt}\n\n/no_think"
+
     payload: dict[str, Any] = {
         "model": selected_model,
         "stream": False,
-        "keep_alive": "10m",
+        "keep_alive": OLLAMA_KEEP_ALIVE,
         "messages": [
             {
                 "role": "system",
@@ -185,14 +221,15 @@ def chat_json(
             },
             {
                 "role": "user",
-                "content": user_prompt,
+                "content": json_user_prompt,
             },
         ],
         "options": {
             "temperature": temperature,
-            "num_ctx": 16384,
+            "num_ctx": OLLAMA_NUM_CTX,
             "seed": 42,
         },
+        "think": OLLAMA_THINK,
         "format": "json",
     }
 
@@ -248,3 +285,112 @@ def chat_json(
         )
 
         return _extract_json_object(repaired_content)
+
+
+def chat_stream(
+    *,
+    model: str | None,
+    system_prompt: str,
+    user_prompt: str,
+    images: list[str] | None = None,
+    timeout: float | None = None,
+    temperature: float = 0.3,
+):
+    """
+    Stream a conversational answer from Ollama /api/chat.
+
+    Yields (kind, text) tuples as tokens arrive, where kind is either
+    "thinking" (the model's private reasoning) or "content" (the answer the
+    user should see). Callers forward these to the browser so the reply
+    appears progressively instead of all at once.
+
+    `images` is an optional list of base64-encoded images (no data: prefix);
+    when present the caller should pass a vision-capable model.
+    """
+
+    selected_model = str(model or DEFAULT_OLLAMA_MODEL).strip()
+
+    if not selected_model:
+        raise ValueError("An Ollama model name is required.")
+
+    # (connect, read) timeout. Read is None = unlimited, so a slow but still
+    # streaming answer is NEVER disconnected before it finishes — only a failure
+    # to connect (Ollama down) errors out quickly. `timeout` (if passed) only
+    # overrides the connect timeout.
+    connect_timeout = timeout if timeout is not None else OLLAMA_CONNECT_TIMEOUT
+    request_timeout = (connect_timeout, None)
+
+    content = user_prompt
+    # qwen3 is a reasoning model: without this it emits a long <think> chain
+    # before answering (slow, and shows "steps" the user doesn't want). The
+    # "/no_think" directive turns that off so it answers directly and fast.
+    if not OLLAMA_THINK and "qwen3" in selected_model.lower():
+        content = f"{content}\n\n/no_think"
+
+    user_message: dict[str, Any] = {
+        "role": "user",
+        "content": content,
+    }
+
+    if images:
+        user_message["images"] = images
+
+    payload: dict[str, Any] = {
+        "model": selected_model,
+        "stream": True,
+        "keep_alive": OLLAMA_KEEP_ALIVE,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            user_message,
+        ],
+        "options": {
+            "temperature": temperature,
+            "num_ctx": OLLAMA_NUM_CTX,
+            "num_predict": OLLAMA_NUM_PREDICT,
+        },
+        "think": OLLAMA_THINK,
+    }
+
+    try:
+        with requests.post(
+            f"{OLLAMA_BASE_URL}/api/chat",
+            json=payload,
+            timeout=request_timeout,
+            stream=True,
+        ) as response:
+            response.raise_for_status()
+
+            for line in response.iter_lines(decode_unicode=True):
+                if not line:
+                    continue
+
+                try:
+                    chunk = json.loads(line)
+                except ValueError:
+                    continue
+
+                if not isinstance(chunk, dict):
+                    continue
+
+                if chunk.get("error"):
+                    raise OllamaUnavailable(str(chunk.get("error")))
+
+                message = chunk.get("message") or {}
+
+                thinking = message.get("thinking")
+                if thinking:
+                    yield ("thinking", thinking)
+
+                content = message.get("content")
+                if content:
+                    yield ("content", content)
+
+                if chunk.get("done"):
+                    break
+
+    except requests.Timeout as exc:
+        raise OllamaUnavailable(
+            "Ollama timed out while generating a response."
+        ) from exc
+    except (requests.RequestException, ValueError) as exc:
+        raise OllamaUnavailable(str(exc)) from exc