Update

README.md

@@ -1,141 +1,10 @@
 ---
-title: Chat
-emoji: 🏆
-colorFrom: pink
-colorTo: purple
+title: Chat Dev
+emoji: 🏃
+colorFrom: purple
+colorTo: gray
 sdk: docker
 pinned: false
-short_description: Inference Port Web Chat
 ---
 
-HuggingFace Docker Space — Node.js WebSocket chat interface for InferencePort AI.
-
-## Environment Variables
-
-Set these as **Secrets** in your HuggingFace Space settings:
-
-| Variable | Required | Description |
-|---|---|---|
-| `SUPABASE_ANON_KEY` | Optional | Supabase anon key (falls back to hardcoded value from app) |
-| `PUBLIC_URL` | Recommended | Full public URL of your Space, e.g. `https://your-user-your-space.hf.space` |
-
-No `SUPABASE_SERVICE_ROLE_KEY` is needed — all DB operations use the user's own access token via RLS.
-
-## HuggingFace Space Setup
-
-1. Create a new **Docker** Space on HuggingFace
-2. Push this repository to the Space
-3. Set `PUBLIC_URL` secret to your space URL (needed for share links)
-4. The app listens on port `7860` which HuggingFace maps automatically
-
-## Supabase Tables Required
-
-Run this SQL in your Supabase project's **SQL Editor**:
-
-```sql
--- Web sessions (separate from Electron app's chat_sessions)
-CREATE TABLE IF NOT EXISTS public.web_sessions (
-  id          uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-  user_id     uuid NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
-  name        text NOT NULL DEFAULT 'New Chat',
-  history     jsonb DEFAULT '[]',
-  model       text,
-  created_at  timestamptz DEFAULT now(),
-  updated_at  timestamptz DEFAULT now()
-);
-
-ALTER TABLE public.web_sessions ENABLE ROW LEVEL SECURITY;
-
-CREATE POLICY "Users can manage their own web sessions"
-  ON public.web_sessions FOR ALL
-  USING (auth.uid() = user_id)
-  WITH CHECK (auth.uid() = user_id);
-
--- Shared sessions (readable by anyone, writable by owner)
-CREATE TABLE IF NOT EXISTS public.shared_sessions (
-  id               uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-  token            text UNIQUE NOT NULL,
-  owner_id         uuid REFERENCES auth.users(id) ON DELETE CASCADE,
-  session_snapshot jsonb NOT NULL,
-  created_at       timestamptz DEFAULT now()
-);
-
-ALTER TABLE public.shared_sessions ENABLE ROW LEVEL SECURITY;
-
-CREATE POLICY "Anyone can read shared sessions"
-  ON public.shared_sessions FOR SELECT USING (true);
-
-CREATE POLICY "Owners can insert shared sessions"
-  ON public.shared_sessions FOR INSERT
-  WITH CHECK (auth.uid() = owner_id);
-
--- User settings (theme, tool toggles)
-CREATE TABLE IF NOT EXISTS public.user_settings (
-  user_id    uuid PRIMARY KEY REFERENCES auth.users(id) ON DELETE CASCADE,
-  settings   jsonb DEFAULT '{}',
-  updated_at timestamptz DEFAULT now()
-);
-
-ALTER TABLE public.user_settings ENABLE ROW LEVEL SECURITY;
-
-CREATE POLICY "Users manage own settings"
-  ON public.user_settings FOR ALL
-  USING (auth.uid() = user_id)
-  WITH CHECK (auth.uid() = user_id);
-```
-
-The `profiles` table already exists from the Electron app and is reused as-is.
-
-## File Structure
-
-```
-inferenceport-web/
-├── Dockerfile
-├── package.json
-├── README.md
-├── server/
-│   ├── index.js          — Express + WebSocket server entry point
-│   ├── wsHandler.js      — All WebSocket message routing
-│   ├── sessionStore.js   — In-memory + Supabase session storage
-│   ├── chatStream.js     — Lightning API streaming + tool execution
-│   ├── auth.js           — Supabase auth verification, profile, subscription
-│   └── rateLimiter.js    — Simple sliding-window rate limiter
-└── public/
-    ├── index.html         — Single page app shell
-    ├── oauth-callback.html — OAuth redirect handler
-    ├── css/
-    │   ├── tokens.css     — CSS variables (colors, spacing, fonts)
-    │   ├── base.css       — Reset, global styles, animations
-    │   ├── sidebar.css    — Collapsible sidebar, session list
-    │   ├── chat.css       — Chat messages, code blocks, media
-    │   ├── input.css      — Center and bottom input bars
-    │   └── modals.css     — Modal overlays, settings, auth forms
-    └── js/
-        ├── ws.js          — WebSocket client (auto-reconnect, request/response)
-        ├── auth.js        — Auth state, Supabase sign-in/out, OAuth
-        ├── sessions.js    — Session list management and rendering
-        ├── chat.js        — Chat rendering, streaming, versioning, editing
-        ├── ui.js          — Notifications, context menus, markdown renderer
-        ├── modals.js      — All modal dialogs (auth, share, settings, tool detail)
-        ├── settings.js    — Settings modal, theme application
-        └── app.js         — Bootstrap, input handling, sidebar, paste/attach
-```
-
-## Architecture Notes
-
-- **WebSocket** is the primary transport for all chat, auth, and session operations
-- **Server memory** stores active sessions; Supabase is the persistence layer for logged-in users
-- **Guest users** get a `tempId` stored in `localStorage`; sessions live in server memory for 12h inactivity / 24h max, with a 15-message daily limit
-- **On login**, temp sessions are transferred to the user's Supabase account automatically
-- **Chat versioning**: each message stores `versions[]`, where each version contains the message content plus the `tail` (all following messages at time of edit). Navigating versions via the `‹ 1/N ›` arrows replays the stored tail
-- **Device sessions** are tracked in server memory only (lost on restart) — no service role key needed
-- **Lightning** at `https://sharktide-lightning.hf.space/gen` is used for all chat streaming and media generation
-
-## Local Development
-
-```bash
-npm install
-PUBLIC_URL=http://localhost:7860 npm run dev
-```
-
-Then open `http://localhost:7860`.
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app-docs.md

@@ -0,0 +1,106 @@
+# InferencePort App Documentation
+
+This document gives the assistant a structured reference for the public web interface, the main settings surfaces, account and media flows, and the current privacy and terms policies. Use the section list tool first, then read only the section that answers the user’s question.
+
+## Pages
+
+- `index.html` is the main app experience. It includes the chat workspace, bottom composer, welcome screen, sidebar, media panel, settings access, authentication entry points, and share-import banner.
+- `admin.html` is a separate administrator page and is not part of the normal end-user workflow.
+- `privacy.html` explains what data the app collects, how it is used, and what the user can expect from storage and third-party services.
+- `terms.html` explains acceptable use, prohibited use, account expectations, and service disclaimers.
+
+## Chat Workspace
+
+- The welcome view is the landing state before a session has visible history. It exposes the centered input for starting a chat.
+- The chat view shows the active conversation, message variants, tool calls, generated media, and message actions like copy, edit, regenerate, and continue.
+- The main composer supports plain text, markdown-style input, attachments, tool toggles, and prompt editing.
+- User message editing creates a new version of the prompt. Follow-up turns continue from the active branch instead of the original branch.
+- Assistant responses can have multiple versions. Users can switch between versions, regenerate a reply, or continue generating from the selected assistant message when appropriate.
+
+## Sidebar And Media Library
+
+- The sidebar contains the chat session list, deleted chat access, media library access, settings access, and account shortcuts.
+- The media library shows folders and saved files, including text documents, rich text documents, images, video, audio, and assistant-generated assets.
+- Signed-in users can upload files, create folders, create notes, rename items, move items, edit text documents, restore trashed items, and permanently delete files.
+- Signed-out or guest users are restricted to download and delete behavior in the media area. Upload and creation actions require sign-in.
+- The three-dot item menu exposes contextual actions like download, rename, move, trash, restore, and delete forever depending on item state and the user’s authentication status.
+
+## Settings And Account
+
+- The Chat settings tab controls theme and tool toggles for web search, image generation, video generation, and audio generation.
+- The Chat settings tab also shows tool usage progress bars, including the free-plan daily web search limit and other tool quotas returned by the usage service.
+- The Personalization tab lets signed-in users edit a private system prompt that is stored for their account and sent before chats.
+- The Memories tab lets users save, edit, and delete persistent short memories that can influence future chats.
+- The Account tab lets signed-in users edit usernames, review the active subscription plan, inspect current device sessions, revoke other sessions, open billing, and delete the account.
+
+## Modals
+
+- Auth modal: sign in, sign up, or continue with supported OAuth providers.
+- Confirm modal: generic confirmation for destructive or sensitive actions.
+- Text prompt modal: used for naming files or folders, entering URLs, and other short-form prompts.
+- Image modal: full-size image preview.
+- Device session modal: details for a logged-in device session with revoke controls.
+- File viewer modal: view or edit attached text files from messages.
+- Tool call modal: shows details of tool arguments and results from assistant tool usage.
+- Media picker modal: choose saved media items to attach into a draft.
+- Folder picker modal: choose a destination folder when moving library items.
+
+## Tool Limits And Credits
+
+- Usage data is fetched from `https://sharktide-lightning.hf.space/usage`.
+- The app shows quota progress when that endpoint returns usage metrics such as daily chat credits, image generations, video generations, audio generations, and free-plan web searches.
+- Free accounts have a local limit of 15 web searches per day inside the app. When the limit is reached, the web search tool should explain that the user has hit the daily free-plan search cap and suggest waiting for reset or upgrading.
+
+## Data Collection
+
+When a user visits the site, the app may collect or process:
+
+- Basic connection metadata such as IP address, browser user agent, and timestamps for security, session tracking, rate limiting, and device session management.
+- Turnstile verification state to confirm the visitor is human before using protected routes or WebSocket actions.
+- Authentication tokens and account identifiers when a user signs in.
+- Chat content, uploaded media, saved memories, settings, personalization prompts, and device session records when those features are used.
+- Usage and subscription information returned by the billing and quota services.
+- Temporary guest identifiers and client identifiers stored in local storage so guest sessions and per-device usage can work.
+
+The app should not claim zero collection. It stores and processes the data needed to provide chats, uploads, settings synchronization, abuse prevention, and billing-aware limits.
+
+## Privacy Policy
+
+InferencePort uses data to operate the service, store chats and media, apply user settings, enforce limits, detect abuse, and support account management. If a user signs in, account-linked data can be synchronized across devices. If a user stays signed out, temporary identifiers may still be stored locally so guest sessions and limits continue to work.
+
+Uploaded files, chat messages, saved memories, and personalization prompts may be stored on the service so the product can retrieve them later. Generated assets may also be stored so they can be re-opened or downloaded. Third-party services may process requests for authentication, verification, billing, quota tracking, web search, and model execution.
+
+The privacy policy should explain that:
+
+- Users should avoid submitting highly sensitive personal data unless they understand the risks.
+- The service may log operational metadata for debugging, billing, moderation, and abuse prevention.
+- Third-party providers may receive request data needed to fulfill product features.
+- Users can delete chats, media, memories, or accounts through the interface, but operational backups or logs may persist briefly where required for reliability or security.
+- No guarantee of absolute security should be stated.
+
+## Terms Of Service
+
+Ethical, legal use is permitted. Users may use the service for ordinary personal, educational, creative, and business tasks so long as their use is lawful and does not harm others or the service.
+
+The terms should make clear that users must not:
+
+- Use the service to break the law, violate contracts, infringe intellectual property, or bypass security controls.
+- Upload or distribute malware, credential theft content, destructive payloads, or instructions intended for abuse.
+- Harass, exploit, impersonate, defraud, stalk, or intentionally harm other people.
+- Attempt to overload, disrupt, scrape, reverse engineer, or misuse the service infrastructure beyond normal permitted use.
+- Use the service to generate or automate clearly illegal activity.
+
+The terms should also explain that:
+
+- Users are responsible for the content they submit and the actions they take using the service.
+- Service availability, quotas, model behavior, and features can change over time.
+- The service may suspend access for abusive, unlawful, or dangerous use.
+- Outputs can be wrong, incomplete, or unsafe and should be reviewed before relying on them.
+- InferencePort AI disclaims responsibility for losses or damages resulting from misuse of the service or from users choosing to run risky content.
+
+## Troubleshooting
+
+- If uploads are disabled, check whether the user is signed in.
+- If web search stops working, check the daily free-plan search limit.
+- If a message edit seems to branch incorrectly, make sure the current selected message version is the one the user expects before sending the next follow-up.
+- If a response shows a retry button, the assistant request or tool flow failed before completion and can usually be retried directly from the conversation.

package.json

@@ -15,6 +15,7 @@
     "ws": "^8.16.0",
     "openai": "^6.29.0",
     "node-fetch": "^3.3.2",
-    "express-rate-limit": "8.3.2"
+    "express-rate-limit": "8.3.2",
+    "tiktoken": "^1.0.0"
   }
 }

server/appDocs.js

@@ -0,0 +1,65 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DOCS_PATH = path.resolve(__dirname, '..', 'app-docs.md');
+
+let cachedSections = [];
+let cachedMtimeMs = 0;
+
+function slugify(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+async function loadSections() {
+  const stats = await fs.stat(DOCS_PATH);
+  if (cachedSections.length && cachedMtimeMs === stats.mtimeMs) return cachedSections;
+
+  const raw = await fs.readFile(DOCS_PATH, 'utf8');
+  const parts = raw.split(/^##\s+/m);
+  const first = parts.shift() || '';
+  const sections = [];
+
+  const overview = first.replace(/^#.*$/m, '').trim();
+  if (overview) {
+    sections.push({
+      id: 'overview',
+      title: 'Overview',
+      content: overview,
+    });
+  }
+
+  parts.forEach((part) => {
+    const lines = part.split('\n');
+    const title = (lines.shift() || '').trim();
+    const content = lines.join('\n').trim();
+    if (!title || !content) return;
+    sections.push({
+      id: slugify(title),
+      title,
+      content,
+    });
+  });
+
+  cachedSections = sections;
+  cachedMtimeMs = stats.mtimeMs;
+  return sections;
+}
+
+export async function listAppDocSections() {
+  const sections = await loadSections();
+  return sections.map(({ id, title }) => ({ id, title }));
+}
+
+export async function readAppDocSection(sectionId) {
+  const target = String(sectionId || '').trim().toLowerCase();
+  if (!target) return null;
+  const sections = await loadSections();
+  return sections.find((section) =>
+    section.id === target || section.title.toLowerCase() === target
+  ) || null;
+}

server/auth.js

@@ -93,13 +93,25 @@ export async function getTierConfig() {
   } catch { return null; }
 }
 
-export async function getUsageInfo(accessToken) {
+export async function getUsageInfo(accessToken, clientId = '') {
   try {
     const h = { Accept: 'application/json' };
     if (accessToken) h.Authorization = `Bearer ${accessToken}`;
+    if (clientId) h['X-Client-ID'] = clientId;
     const r = await fetch('https://sharktide-lightning.hf.space/usage', { headers: h });
-    return r.ok ? r.json() : null;
-  } catch { return null; }
+    const payload = r.ok ? await r.json() : null;
+    console.log('[Usage API]', JSON.stringify({
+      ok: r.ok,
+      status: r.status,
+      clientId: clientId || null,
+      hasAuth: !!accessToken,
+      payload,
+    }));
+    return payload;
+  } catch (err) {
+    console.error('[Usage API] request failed:', err.message);
+    return null;
+  }
 }
 
 function defaultSettings() {

server/chatStream.js

@@ -5,6 +5,12 @@ import path from "path";
 import { LIGHTNING_BASE } from "./config.js";
 import WebSocket from "ws";
 import crypto from "crypto";
+import { encoding_for_model } from "tiktoken";
+import { mediaStore } from "./mediaStore.js";
+import { memoryStore } from "./memoryStore.js";
+import { systemPromptStore } from "./systemPromptStore.js";
+import { consumeWebSearchUsage } from "./webSearchUsageStore.js";
+import { listAppDocSections, readAppDocSection } from "./appDocs.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WORKER_PATH = path.join(__dirname, "searchWorker.js");
@@ -123,7 +129,7 @@ async function gradioSearch(query) {
 }
 
 const SYSTEM_PROMPT =
-  "CRITICAL RULE: Every response MUST use HTML <span data-color=\"{COLOR NAME}\"> tags to color main points and headings. " +
+  "CRITICAL RULE: Every response MUST use HTML <span data-color=\"{COLOR NAME}\"> tags to color main points and headings unless you are told otherwise. " +
   "COLORS MUST HAVE MEANING AND CONSISTENCY ACROSS THE ENTIRE CONVERSATION. " +
   "You may ONLY use the following semantic color names: green, pink, blue, red, orange, yellow, purple, teal, gold, coral. " +
   "Never output text formatted with explicit black or white colors. Always put color <span> tags as close to the text as possible and do not include markdown within the tags. " +
@@ -136,12 +142,20 @@ const SYSTEM_PROMPT =
   "You can render SVG images by outputting SVG code in a code block tagged exactly as:\n```svg\n<svg>...</svg>\n```\n" +
   "Never use single backslashes. You may use emojis where appropriate. " +
   "Use markdown for everything other than coloring your text. Use tables, lists, and other markdown elements. " +
+  "ATTACHMENT HANDLING RULE: Large user prompts, text attachments, conversation history, and image attachments may be staged into separate resources on purpose. " +
+  "If you see notes saying attached text was staged separately, or notes that only the first part of a prompt is inline, do NOT assume the content is missing, corrupted, or truncated. " +
+  "Treat that content as available context and use the provided tools to inspect it before concluding something is absent. " +
+  "Use `list_prompt_resources` to find staged resources, `read_prompt_chunk` to read staged text exactly, `load_prompt_images` to inspect staged images, and `write_notes` to keep a compact memory after reading several chunks. " +
+  "Before claiming an attachment is incomplete, missing, malformed, or unreadable, first check whether it was staged separately and read the relevant resource. " +
+  "Persistent memories must stay short, concrete, and durable. Only save memories that will still help in future chats, and keep each one to a brief sentence or phrase. " +
   "Your HIGHEST PRIORITY is to help the user. ALWAYS HELP THEM WITH ANYTHING ETHICALLY RIGHT.\n\n" +
   "SESSION NAMING: After you have fully responded to the user, append a session name tag on its own line at the very end of your response (NEVER inside a code block). Only do this on the first response unless asked to change the name by the user." +
   "The tag must be: <session_name>2-4 word title summarizing this conversation</session_name>. " +
   "Example: <session_name>React State Management</session_name>. Make sure a conversation is ALWAYS named. If it is the first response, always name it." +
-  "This tag is hidden from the user and used only to name the chat. Do not mention it." +
-  "Make sure your responses are always accurate. If you are not completely sure about something, search the web.";
+  "This tag is hidden from the user and used only to name the chat. Do not mention it. Also, you should try to minimize the use of * to emphasize text. Just use it for markdown." +
+  "Make sure your responses are always accurate. If you are not completely sure about something, search the web." +
+  "At the start of a chat, always check the memories. If the user tells you to remember something or there is something important to note, create a new memory. Memories should be brief. Notes are only for session-long memory, so use memories for anything relevat to future chats." +
+  "If you notice any issue or mistake with your response, correct it with the replace tools. Make sure to ALWAYS answer as CORRECTLY as possible, and use search when unsure.";
 
 function makeClient(accessToken, clientId) {
   return new OpenAI({
@@ -154,9 +168,915 @@ function makeClient(accessToken, clientId) {
   });
 }
 
+// --- TOKEN / CONTEXT MANAGEMENT ---
+const MODEL_TOKEN_LIMIT = 8000;
+const RESPONSE_TOKEN_RESERVE = 600;
+const WORKING_PROMPT_BUDGET = MODEL_TOKEN_LIMIT - RESPONSE_TOKEN_RESERVE;
+const INLINE_USER_PROMPT_TOKENS = 5000;
+const MAX_AGENT_STEPS = 12;
+const CHUNK_SIZE = 700;
+const MAX_INLINE_IMAGES = 3;
+const RECENT_HISTORY_MAX_MESSAGES = 6;
+const RECENT_HISTORY_TOKEN_BUDGET = 900;
+const HISTORY_SUMMARY_TOKEN_BUDGET = 600;
+const NOTES_TOKEN_BUDGET = 900;
+const MAX_DYNAMIC_MESSAGES = 10;
+const MAX_UPSTREAM_RATE_LIMIT_RETRIES = 4;
+const DEFAULT_UPSTREAM_RETRY_MS = 4000;
+const MAX_UPSTREAM_RETRY_MS = 15000;
+const UPSTREAM_RETRY_BUFFER_MS = 350;
+
+// In-memory stores for staged prompt resources and assistant notes
+const promptContextStore = new Map();     // sessionId -> { resources, resourcesById }
+const assistantNotesStore = new Map();    // sessionId -> [{ step, note }]
+
+// Initialize tiktoken encoder
+const enc = encoding_for_model("gpt-4"); // maps well to gpt-oss:120b
+const tokenDecoder = new TextDecoder("utf-8");
+
+function countTokens(text) {
+  return enc.encode(String(text || "")).length;
+}
+
+function decodeTokenSlice(tokens) {
+  const decoded = enc.decode(tokens);
+  return typeof decoded === "string" ? decoded : tokenDecoder.decode(decoded);
+}
+
+function countMessageTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      total += countTokens(msg.content);
+      continue;
+    }
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text") total += countTokens(block.text);
+        else if (block.type === "image_url") total += 85;
+      }
+    }
+  }
+  return total;
+}
+
+function compactWhitespace(text) {
+  return String(text || "").replace(/\s+/g, " ").trim();
+}
+
+function makePreview(text, maxChars = 160) {
+  const compact = compactWhitespace(text);
+  if (!compact) return "Empty.";
+  return compact.length <= maxChars ? compact : `${compact.slice(0, maxChars - 3)}...`;
+}
+
+function stripHtml(text) {
+  return String(text || "").replace(/<[^>]+>/g, " ");
+}
+
+function splitTextByTokenLimit(text, tokenLimit) {
+  const source = String(text || "");
+  const tokens = enc.encode(source);
+  if (tokens.length <= tokenLimit) {
+    return { head: source, tail: "" };
+  }
+  return {
+    head: decodeTokenSlice(tokens.slice(0, tokenLimit)),
+    tail: decodeTokenSlice(tokens.slice(tokenLimit)),
+  };
+}
+
+function chunkTextWithMetadata(text, chunkSize = CHUNK_SIZE) {
+  const source = String(text || "");
+  const tokens = enc.encode(source);
+  const chunks = [];
+
+  for (let i = 0; i < tokens.length; i += chunkSize) {
+    const chunkText = decodeTokenSlice(tokens.slice(i, i + chunkSize));
+    chunks.push({
+      index: chunks.length,
+      text: chunkText,
+      tokenCount: countTokens(chunkText),
+      preview: makePreview(chunkText, 120),
+    });
+  }
+
+  return chunks;
+}
+
+function makeResourceSlug(value) {
+  return compactWhitespace(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .slice(0, 40) || "resource";
+}
+
+function createPromptState(sessionId) {
+  const state = {
+    sessionId,
+    createdAt: Date.now(),
+    resources: [],
+    resourcesById: new Map(),
+  };
+  promptContextStore.set(sessionId, state);
+  assistantNotesStore.set(sessionId, []);
+  return state;
+}
+
+function getPromptState(sessionId) {
+  return promptContextStore.get(sessionId);
+}
+
+function clearPromptState(sessionId) {
+  promptContextStore.delete(sessionId);
+  assistantNotesStore.delete(sessionId);
+}
+
+function createResourceId(state, kind, name) {
+  const base = `${kind}_${makeResourceSlug(name)}`;
+  let id = base;
+  let suffix = 2;
+
+  while (state.resourcesById.has(id)) {
+    id = `${base}_${suffix++}`;
+  }
+
+  return id;
+}
+
+function registerTextResource(state, { kind, name, text }) {
+  const normalizedText = String(text ?? "").trim();
+  if (!normalizedText) return null;
+
+  const resource = {
+    id: createResourceId(state, kind, name),
+    kind,
+    name,
+    totalTokens: countTokens(normalizedText),
+    chunkCount: 0,
+    preview: makePreview(normalizedText),
+    chunks: chunkTextWithMetadata(normalizedText),
+  };
+  resource.chunkCount = resource.chunks.length;
+
+  state.resources.push(resource);
+  state.resourcesById.set(resource.id, resource);
+  return resource;
+}
+
+function registerImageResource(state, { name, images, inlineImageCount = 0 }) {
+  const normalizedImages = (images || [])
+    .filter(Boolean)
+    .map((block, index) => ({
+      index,
+      block: { ...block },
+    }));
+
+  if (!normalizedImages.length) return null;
+
+  const resource = {
+    id: createResourceId(state, "images", name),
+    kind: "images",
+    name,
+    imageCount: normalizedImages.length,
+    inlineImageCount,
+    preview: `${normalizedImages.length} image(s)`,
+    images: normalizedImages,
+  };
+
+  state.resources.push(resource);
+  state.resourcesById.set(resource.id, resource);
+  return resource;
+}
+
+function parseTextAttachmentsFromDetails(text) {
+  const source = String(text || "");
+  if (!source.trim()) return { text: "", attachments: [] };
+
+  const detailsRegex = /<details>\s*<summary>(.*?)<\/summary>\s*([\s\S]*?)<\/details>/gi;
+  const codeBlockRegex = /```(?:[\w+-]+)?\n?([\s\S]*?)```/g;
+  const attachments = [];
+  const parts = [];
+  let lastIndex = 0;
+  let attachmentCounter = 1;
+  let match;
+
+  while ((match = detailsRegex.exec(source))) {
+    parts.push(source.slice(lastIndex, match.index));
+
+    const summary = compactWhitespace(match[1]) || `attachment_${attachmentCounter}`;
+    const innerContent = match[2] || "";
+    const codeBlocks = [...innerContent.matchAll(codeBlockRegex)];
+
+    if (codeBlocks.length) {
+      codeBlocks.forEach((codeMatch, index) => {
+        attachments.push({
+          name: codeBlocks.length > 1 ? `${summary} part ${index + 1}` : summary,
+          content: codeMatch[1],
+        });
+      });
+    } else {
+      const plainText = stripHtml(innerContent).trim();
+      if (plainText) {
+        attachments.push({ name: summary, content: plainText });
+      }
+    }
+
+    parts.push(`\n[Attached text "${summary}" was staged separately from the inline prompt.]\n`);
+    lastIndex = match.index + match[0].length;
+    attachmentCounter++;
+  }
+
+  parts.push(source.slice(lastIndex));
+  return {
+    text: parts.join("").trim(),
+    attachments,
+  };
+}
+
+function contentToText(content, { preview = false } = {}) {
+  if (typeof content === "string") {
+    return preview ? makePreview(content, 220) : String(content || "");
+  }
+
+  if (!Array.isArray(content)) return "";
+
+  const textParts = [];
+  let imageCount = 0;
+
+  for (const block of content) {
+    if (block.type === "text" && block.text) textParts.push(block.text);
+    else if (block.type === "image_url") imageCount++;
+  }
+
+  const pieces = [];
+  const text = textParts.join("\n\n").trim();
+  if (text) pieces.push(preview ? makePreview(text, 220) : text);
+  if (imageCount) pieces.push(`[${imageCount} image attachment(s)]`);
+  return pieces.join(preview ? " " : "\n");
+}
+
+function getAllowedToolNames(toolDefs = []) {
+  return toolDefs
+    .map((tool) => tool?.function?.name)
+    .filter(Boolean);
+}
+
+function sanitizeToolName(rawName, allowedToolNames = []) {
+  if (!rawName) return null;
+
+  let name = String(rawName).trim();
+  if (!name) return null;
+
+  name = name.replace(/<\|[\s\S]*$/, "").trim();
+  name = name.replace(/^["'`]+|["'`]+$/g, "");
+
+  const identifierMatch = name.match(/^[A-Za-z0-9_-]+/);
+  if (identifierMatch) {
+    name = identifierMatch[0];
+  }
+
+  if (!allowedToolNames.length) {
+    return name || null;
+  }
+
+  if (allowedToolNames.includes(name)) {
+    return name;
+  }
+
+  const normalizedRaw = String(rawName).toLowerCase();
+  const prefixedMatch = allowedToolNames.find((allowedName) =>
+    normalizedRaw.startsWith(allowedName.toLowerCase())
+  );
+  if (prefixedMatch) {
+    return prefixedMatch;
+  }
+
+  const embeddedMatch = allowedToolNames.find((allowedName) =>
+    normalizedRaw.includes(allowedName.toLowerCase())
+  );
+  return embeddedMatch || null;
+}
+
+function normalizeStoredToolCalls(toolCalls = []) {
+  return toolCalls.map((call) => ({
+    id: call.id || `call_${crypto.randomUUID()}`,
+    type: "function",
+    function: {
+      name: sanitizeToolName(call.name || call.function?.name || "unknown_tool"),
+      arguments: (() => {
+        const rawArgs = call.args ?? call.function?.arguments ?? {};
+        return typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs);
+      })(),
+    },
+  }));
+}
+
+function getMessageToolNames(msg) {
+  const rawCalls = Array.isArray(msg.tool_calls)
+    ? msg.tool_calls
+    : Array.isArray(msg.toolCalls)
+      ? msg.toolCalls
+      : [];
+
+  return rawCalls
+    .map((call) => call?.function?.name || call?.name)
+    .filter(Boolean);
+}
+
+function describeMessageForSummary(msg) {
+  const role = (msg.role || "message").toUpperCase();
+  const contentPreview = contentToText(msg.content, { preview: true }) || "[no text]";
+  const toolNames = getMessageToolNames(msg);
+  const suffix = toolNames.length ? ` [tools: ${toolNames.join(", ")}]` : "";
+  return `${role}: ${contentPreview}${suffix}`;
+}
+
+function messagesToTranscript(messages) {
+  return messages
+    .map((msg) => {
+      const toolNames = getMessageToolNames(msg);
+      const lines = [
+        `${(msg.role || "message").toUpperCase()}:`,
+        contentToText(msg.content) || "[no text]",
+      ];
+      if (toolNames.length) {
+        lines.push(`[tool calls: ${toolNames.join(", ")}]`);
+      }
+      return lines.join("\n");
+    })
+    .join("\n\n");
+}
+
+function buildHistorySummary(messages, tokenBudget = HISTORY_SUMMARY_TOKEN_BUDGET) {
+  const lines = [];
+  let usedTokens = 0;
+
+  for (let i = 0; i < messages.length; i++) {
+    const line = `- ${describeMessageForSummary(messages[i])}`;
+    const lineTokens = countTokens(line);
+    if (usedTokens + lineTokens > tokenBudget) {
+      lines.push(`- ${messages.length - i} earlier message(s) were omitted from this summary.`);
+      break;
+    }
+    lines.push(line);
+    usedTokens += lineTokens;
+  }
+
+  return lines.join("\n");
+}
+
+function buildPromptResourceManifest(state) {
+  return {
+    resource_count: state?.resources?.length || 0,
+    resources: (state?.resources || []).map((resource) => {
+      if (resource.kind === "images") {
+        return {
+          id: resource.id,
+          kind: resource.kind,
+          name: resource.name,
+          image_count: resource.imageCount,
+          inline_image_count: resource.inlineImageCount,
+          preview: resource.preview,
+        };
+      }
+
+      return {
+        id: resource.id,
+        kind: resource.kind,
+        name: resource.name,
+        chunk_count: resource.chunkCount,
+        total_tokens: resource.totalTokens,
+        preview: resource.preview,
+      };
+    }),
+  };
+}
+
+function formatResourceManifestLine(resource) {
+  if (resource.kind === "images") {
+    const inlineNote = resource.inlineImageCount
+      ? `, first ${resource.inlineImageCount} already inline`
+      : "";
+    return `- \`${resource.id}\` (${resource.kind}, ${resource.imageCount} image(s)${inlineNote})`;
+  }
+
+  return `- \`${resource.id}\` (${resource.kind}, ${resource.chunkCount} chunk(s), ${resource.totalTokens} tokens): ${resource.preview}`;
+}
+
+function findPromptResource(state, resourceId) {
+  if (!state || !resourceId) return null;
+  return (
+    state.resourcesById.get(resourceId) ||
+    state.resources.find((resource) => resource.name === resourceId) ||
+    null
+  );
+}
+
+function appendAssistantNote(sessionId, note) {
+  const normalizedNote = compactWhitespace(note);
+  if (!normalizedNote) return;
+
+  const notes = assistantNotesStore.get(sessionId) || [];
+  if (notes[notes.length - 1]?.note === normalizedNote) return;
+
+  notes.push({ step: notes.length + 1, note: normalizedNote });
+
+  while (
+    notes.length > 1 &&
+    countTokens(notes.map((entry) => `- ${entry.note}`).join("\n")) > NOTES_TOKEN_BUDGET
+  ) {
+    notes.shift();
+  }
+
+  assistantNotesStore.set(sessionId, notes);
+}
+
+function buildAssistantNotesMessage(sessionId) {
+  const notes = assistantNotesStore.get(sessionId) || [];
+  if (!notes.length) return null;
+
+  return {
+    role: "system",
+    content: [
+      "Working notes captured during this response:",
+      ...notes.map((entry) => `- ${entry.note}`),
+    ].join("\n"),
+  };
+}
+
+function buildCompactionSummaryMessage(messages) {
+  if (!messages.length) return null;
+
+  const toolNames = new Set();
+  let toolResultCount = 0;
+  let imageBatchCount = 0;
+
+  for (const msg of messages) {
+    for (const name of getMessageToolNames(msg)) {
+      toolNames.add(name);
+    }
+    if (msg.role === "tool") toolResultCount++;
+    if (
+      msg.role === "user" &&
+      Array.isArray(msg.content) &&
+      msg.content.some((block) => block.type === "image_url")
+    ) {
+      imageBatchCount++;
+    }
+  }
+
+  const details = [];
+  if (toolNames.size) details.push(`tools: ${[...toolNames].join(", ")}`);
+  if (toolResultCount) details.push(`${toolResultCount} prior tool result(s)`);
+  if (imageBatchCount) details.push(`${imageBatchCount} prior image batch(es)`);
+
+  return {
+    role: "system",
+    content: `Earlier tool interactions in this response were compacted to stay within the context window${details.length ? ` (${details.join("; ")})` : ""}. Reread any chunk or image batch if you need the exact content again.`,
+  };
+}
+
+function buildModelMessages(baseMessages, workingMessages, sessionId) {
+  const notesMessage = buildAssistantNotesMessage(sessionId);
+  const messages = [...baseMessages];
+  if (notesMessage) messages.push(notesMessage);
+
+  const budgetLeft = Math.max(0, WORKING_PROMPT_BUDGET - countMessageTokens(messages));
+  const keptMessages = [];
+  let keptTokens = 0;
+
+  for (let i = workingMessages.length - 1; i >= 0; i--) {
+    const candidate = workingMessages[i];
+    const candidateTokens = countMessageTokens([candidate]);
+    if (keptMessages.length >= MAX_DYNAMIC_MESSAGES) {
+      break;
+    }
+    if (keptMessages.length > 0 && keptTokens + candidateTokens > budgetLeft) {
+      break;
+    }
+    keptMessages.unshift(candidate);
+    keptTokens += candidateTokens;
+    if (keptMessages.length === 1 && candidateTokens > budgetLeft) {
+      break;
+    }
+  }
+
+  const omittedMessages = workingMessages.slice(0, workingMessages.length - keptMessages.length);
+  const summaryMessage = buildCompactionSummaryMessage(omittedMessages);
+  if (summaryMessage) {
+    const withSummary = [...messages, summaryMessage, ...keptMessages];
+    if (countMessageTokens(withSummary) <= WORKING_PROMPT_BUDGET) {
+      messages.push(summaryMessage);
+    }
+  }
+
+  messages.push(...keptMessages);
+  return messages;
+}
+
+function prepareHistoryContext(history, state) {
+  const normalizedHistory = history.filter(Boolean);
+  if (!normalizedHistory.length) {
+    return { summaryMessages: [], recentMessages: [] };
+  }
+
+  const recentMessages = [];
+  let recentTokens = 0;
+
+  for (let i = normalizedHistory.length - 1; i >= 0; i--) {
+    const candidate = normalizedHistory[i];
+    const candidateTokens = countMessageTokens([candidate]);
+    if (
+      recentMessages.length >= RECENT_HISTORY_MAX_MESSAGES ||
+      recentTokens + candidateTokens > RECENT_HISTORY_TOKEN_BUDGET
+    ) {
+      break;
+    }
+    recentMessages.unshift(candidate);
+    recentTokens += candidateTokens;
+  }
+
+  const olderMessages = normalizedHistory.slice(0, normalizedHistory.length - recentMessages.length);
+  if (!olderMessages.length) {
+    return { summaryMessages: [], recentMessages };
+  }
+
+  const historyResource = registerTextResource(state, {
+    kind: "history",
+    name: "Earlier conversation",
+    text: messagesToTranscript(olderMessages),
+  });
+
+  const summaryMessages = historyResource
+    ? [
+        {
+          role: "system",
+          content: [
+            "Earlier conversation was condensed to keep the live prompt smaller.",
+            `Summary:\n${buildHistorySummary(olderMessages)}`,
+            `If exact earlier wording matters, use \`read_prompt_chunk\` with resource_id "${historyResource.id}".`,
+          ].join("\n\n"),
+        },
+      ]
+    : [];
+
+  return { summaryMessages, recentMessages };
+}
+
+function prepareCurrentUserContext(userMessage, state) {
+  const attachments = [];
+  const imageBlocks = [];
+  const textParts = [];
+
+  if (typeof userMessage === "string") {
+    const parsed = parseTextAttachmentsFromDetails(userMessage);
+    if (parsed.text) textParts.push(parsed.text);
+    attachments.push(...parsed.attachments);
+  } else if (Array.isArray(userMessage)) {
+    for (const item of userMessage) {
+      if (item?.type === "text" && item.text?.trim()) {
+        const parsed = parseTextAttachmentsFromDetails(item.text);
+        if (parsed.text) textParts.push(parsed.text);
+        attachments.push(...parsed.attachments);
+      } else if (item?.type === "image_url") {
+        imageBlocks.push(item);
+      }
+    }
+  }
+
+  const rawPrimaryText = textParts.join("\n\n").trim();
+  const fallbackText = imageBlocks.length
+    ? "[Image(s) attached]"
+    : attachments.length
+      ? "[Text attachment(s) attached]"
+      : "";
+  const primaryText = rawPrimaryText || fallbackText;
+
+  const { head: inlineTextHead, tail: overflowText } = splitTextByTokenLimit(
+    primaryText,
+    INLINE_USER_PROMPT_TOKENS
+  );
+
+  if (overflowText.trim()) {
+    registerTextResource(state, {
+      kind: "prompt",
+      name: "Current user prompt continuation",
+      text: overflowText,
+    });
+  }
+
+  for (const attachment of attachments) {
+    registerTextResource(state, {
+      kind: "attachment",
+      name: attachment.name,
+      text: attachment.content,
+    });
+  }
+
+  let inlineImages = imageBlocks;
+  if (imageBlocks.length > MAX_INLINE_IMAGES) {
+    inlineImages = imageBlocks.slice(0, MAX_INLINE_IMAGES);
+    registerImageResource(state, {
+      name: "Current user images",
+      images: imageBlocks,
+      inlineImageCount: inlineImages.length,
+    });
+  }
+
+  const stagingNotes = [];
+  if (overflowText.trim()) {
+    stagingNotes.push(`Only the first ${INLINE_USER_PROMPT_TOKENS} tokens of the current prompt are inline.`);
+  }
+  if (attachments.length) {
+    stagingNotes.push(`${attachments.length} text attachment(s) were staged separately.`);
+  }
+  if (imageBlocks.length > inlineImages.length) {
+    stagingNotes.push(`${imageBlocks.length - inlineImages.length} additional image(s) were staged separately.`);
+  }
+
+  const inlineText = [
+    inlineTextHead.trim() || fallbackText,
+    stagingNotes.length
+      ? `[Context note: ${stagingNotes.join(" ")} See the staged context guide for resource IDs.]`
+      : null,
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+
+  const userMessages = [];
+  if (Array.isArray(userMessage) || inlineImages.length) {
+    userMessages.push({
+      role: "user",
+      content: [
+        { type: "text", text: inlineText || "[Image(s) attached]" },
+        ...inlineImages,
+      ],
+    });
+  } else if (inlineText) {
+    userMessages.push({ role: "user", content: inlineText });
+  }
+
+  const contextMessages = state.resources.length
+    ? [
+        {
+          role: "system",
+          content: [
+            "Large prompt context was staged into smaller pieces.",
+            "Those staged resources are available context, not missing text.",
+            "Start with the inline user message, then use tools to inspect omitted prompt text, attachments, history, or images.",
+            "Use `list_prompt_resources` for the full manifest.",
+            "Use `read_prompt_chunk` for exact text.",
+            state.resources.some((resource) => resource.kind === "images")
+              ? "Use `load_prompt_images` to inspect omitted images in smaller batches."
+              : null,
+            "After reading multiple chunks, use `write_notes` to keep a compact working memory.",
+            "",
+            "Staged resources:",
+            ...state.resources.map(formatResourceManifestLine),
+          ]
+            .filter(Boolean)
+            .join("\n"),
+        },
+      ]
+    : [];
+
+  return { contextMessages, userMessages };
+}
+
+function buildMemorySystemMessages(memories = [], sessionName = "") {
+  const messages = [];
+  if (sessionName) {
+    messages.push({
+      role: "system",
+      content: `Current session name: "${sessionName}". This is hidden metadata and may help with continuity if the user references the chat title.`,
+    });
+  }
+  if (memories.length) {
+    messages.push({
+      role: "system",
+      content: [
+        "Persistent memories from earlier chats:",
+        ...memories.map((memory, index) => `${index + 1}. ${memory.content}`),
+        "Treat these as concise background notes. If one is outdated or wrong, prefer the user's current message.",
+      ].join("\n"),
+    });
+  }
+  return messages;
+}
+
+function buildBasePromptMessages({ sessionId, history, userMessage, memories = [], sessionName = "", systemPrompt = "" }) {
+  const state = createPromptState(sessionId);
+  const normalizedHistory = history.map(normalizeMessage).filter(Boolean);
+  const { summaryMessages, recentMessages } = prepareHistoryContext(normalizedHistory, state);
+  const { contextMessages, userMessages } = prepareCurrentUserContext(userMessage, state);
+
+  return [
+    { role: "system", content: systemPrompt || SYSTEM_PROMPT },
+    ...buildMemorySystemMessages(memories, sessionName),
+    ...summaryMessages,
+    ...recentMessages,
+    ...contextMessages,
+    ...userMessages,
+  ];
+}
+
+class RetryableRateLimitError extends Error {
+  constructor(message, retryAfterMs, internalMessage = null) {
+    super(message);
+    this.name = "RetryableRateLimitError";
+    this.retryAfterMs = retryAfterMs;
+    this.internalMessage = internalMessage || message;
+    this.publicMessage = "The model provider is temporarily rate limited. Retrying automatically.";
+  }
+}
+
+class UpstreamProviderError extends Error {
+  constructor(publicMessage, internalMessage = null) {
+    super(publicMessage);
+    this.name = "UpstreamProviderError";
+    this.publicMessage = publicMessage;
+    this.internalMessage = internalMessage || publicMessage;
+  }
+}
+
+function getErrorText(errorPayload) {
+  if (typeof errorPayload === "string") {
+    let text = errorPayload.trim();
+
+    if (text.startsWith("[ERROR]")) {
+      text = text.slice("[ERROR]".length).trim();
+    }
+
+    if (
+      (text.startsWith("\"") && text.endsWith("\"")) ||
+      (text.startsWith("'") && text.endsWith("'"))
+    ) {
+      try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === "string") {
+          text = parsed;
+        }
+      } catch {
+        // Keep the original text if it is not valid JSON.
+      }
+    }
+
+    return text;
+  }
+  if (!errorPayload) return "";
+  if (typeof errorPayload.message === "string") return errorPayload.message;
+  try {
+    return JSON.stringify(errorPayload);
+  } catch {
+    return String(errorPayload);
+  }
+}
+
+function isRateLimitError(errorPayload) {
+  const text = getErrorText(errorPayload).toLowerCase();
+  const code = String(errorPayload?.code || errorPayload?.error?.code || "").toLowerCase();
+  const type = String(errorPayload?.type || errorPayload?.error?.type || "").toLowerCase();
+  const status = Number(errorPayload?.status || errorPayload?.error?.status || 0);
+
+  return (
+    status === 429 ||
+    code === "rate_limit_exceeded" ||
+    type === "tokens" ||
+    text.includes("rate limit") ||
+    text.includes("rate limit reached") ||
+    text.includes("rate_limit_exceeded") ||
+    text.includes("upstream provider error (429)") ||
+    text.includes("(429)") ||
+    text.includes(" 429")
+  );
+}
+
+function isEmbeddedProviderErrorText(text) {
+  const normalized = getErrorText(text).toLowerCase();
+  return (
+    normalized.startsWith("upstream provider error") ||
+    normalized.startsWith("provider error") ||
+    normalized.includes("upstream provider error") ||
+    normalized.includes("rate_limit_exceeded") ||
+    normalized.includes("rate limit reached")
+  );
+}
+
+function extractRetryAfterMs(errorPayload) {
+  const text = getErrorText(errorPayload);
+  const directValue = Number(
+    errorPayload?.retryAfterMs ??
+    errorPayload?.retry_after_ms ??
+    errorPayload?.retry_after ??
+    errorPayload?.error?.retryAfterMs ??
+    errorPayload?.error?.retry_after_ms ??
+    errorPayload?.error?.retry_after
+  );
+
+  if (Number.isFinite(directValue) && directValue > 0) {
+    return directValue > 100 ? directValue : directValue * 1000;
+  }
+
+  const secondsMatch =
+    text.match(/try again in\s*([\d.]+)\s*s/i) ||
+    text.match(/retry after\s*([\d.]+)\s*s/i) ||
+    text.match(/in\s*([\d.]+)\s*seconds?/i);
+  if (secondsMatch) {
+    return Math.ceil(Number(secondsMatch[1]) * 1000);
+  }
+
+  const millisecondsMatch = text.match(/retry after\s*([\d.]+)\s*ms/i);
+  if (millisecondsMatch) {
+    return Math.ceil(Number(millisecondsMatch[1]));
+  }
+
+  return null;
+}
+
+function createAbortError() {
+  const err = new Error("AbortError");
+  err.name = "AbortError";
+  return err;
+}
+
+async function sleepWithAbort(ms, abortSignal) {
+  if (!ms || ms <= 0) return;
+  if (abortSignal?.aborted) throw createAbortError();
+
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      abortSignal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+
+    const onAbort = () => {
+      clearTimeout(timer);
+      abortSignal?.removeEventListener("abort", onAbort);
+      reject(createAbortError());
+    };
+
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+function getRetryDelayMs(error, retryIndex) {
+  const hintedDelay = Number(error?.retryAfterMs);
+  if (Number.isFinite(hintedDelay) && hintedDelay > 0) {
+    return Math.min(MAX_UPSTREAM_RETRY_MS, hintedDelay + UPSTREAM_RETRY_BUFFER_MS);
+  }
+
+  return Math.min(
+    MAX_UPSTREAM_RETRY_MS,
+    DEFAULT_UPSTREAM_RETRY_MS * Math.max(1, retryIndex + 1)
+  );
+}
+
+function getPublicErrorMessage(err) {
+  if (!err) return "The request failed.";
+  if (err.name === "RetryableRateLimitError") {
+    return "The model provider is temporarily rate limited. Please try again in a few seconds.";
+  }
+  if (err.publicMessage) return err.publicMessage;
+  return String(err);
+}
+
+async function websocketChatStreamWithRetry(body, headers, onToken, abortSignal) {
+  for (let retryIndex = 0; ; retryIndex++) {
+    try {
+      return await websocketChatStream(body, headers, onToken, abortSignal);
+    } catch (err) {
+      if (err?.name === "AbortError") throw err;
+
+      const retryable = err?.name === "RetryableRateLimitError";
+      if (!retryable || retryIndex >= MAX_UPSTREAM_RATE_LIMIT_RETRIES) {
+        throw err;
+      }
+
+      const waitMs = getRetryDelayMs(err, retryIndex);
+      console.warn(
+        `[streamChat] Upstream rate limited, retrying in ${waitMs}ms (${retryIndex + 1}/${MAX_UPSTREAM_RATE_LIMIT_RETRIES})`
+      );
+      await sleepWithAbort(waitMs, abortSignal);
+    }
+  }
+}
+
+function serializeToolCalls(toolCallBuffer) {
+  return [...toolCallBuffer.values()]
+    .filter((toolCall) => toolCall?.name)
+    .map((toolCall) => ({
+      id: toolCall.id || `call_${crypto.randomUUID()}`,
+      type: "function",
+      function: { name: toolCall.name, arguments: toolCall.arguments },
+    }));
+}
+
 export async function websocketChatStream(body, headers, onToken, abortSignal) {
   const ws = await getSafeWebSocket();
   const currentRequestId = ++requestIdCounter;
+  const allowedToolNames = getAllowedToolNames(body?.tools);
   const safeParse = (str) => {
     try { return JSON.parse(str.startsWith("data: ") ? str.slice(6) : str); } catch { return null; }
   };
@@ -170,11 +1090,7 @@ export async function websocketChatStream(body, headers, onToken, abortSignal) {
       if (!finished) {
         finished = true;
         cleanup();
-        const toolCalls = [...toolCallBuffer.values()].map((t) => ({
-          id: t.id || `call_${crypto.randomUUID()}`,
-          type: "function",
-          function: { name: t.name, arguments: t.arguments },
-        }));
+        const toolCalls = serializeToolCalls(toolCallBuffer);
         resolve({ assistantText, toolCalls });
       }
     }, 120000);
@@ -195,19 +1111,80 @@ export async function websocketChatStream(body, headers, onToken, abortSignal) {
       if (!payload) return;
 
       if (payload.error && !payload.choices) {
-        if (onToken) onToken(`[ERROR] ${JSON.stringify(payload.error)}`);
-        if (!finished) { finished = true; cleanup(); resolve({ assistantText, toolCalls: [...toolCallBuffer.values()] }); }
+        if (!finished) {
+          finished = true;
+          cleanup();
+
+          const errorText = getErrorText(payload.error);
+          const hasPartialOutput = assistantText.length > 0 || toolCallBuffer.size > 0;
+
+          if (!hasPartialOutput && isRateLimitError(payload.error)) {
+            reject(
+              new RetryableRateLimitError(
+                "The model provider is temporarily rate limited.",
+                extractRetryAfterMs(payload.error),
+                errorText
+              )
+            );
+          } else {
+            reject(
+              new UpstreamProviderError(
+                hasPartialOutput
+                  ? "The model provider interrupted the response. Please try again."
+                  : "The model provider returned an error. Please try again.",
+                errorText
+              )
+            );
+          }
+        }
         return;
       }
 
       const delta = payload.choices?.[0]?.delta;
-      if (delta?.content) { assistantText += delta.content; if (onToken) onToken(delta.content); }
+      if (delta?.content) {
+        const contentText = String(delta.content);
+
+        if (isEmbeddedProviderErrorText(contentText)) {
+          if (!finished) {
+            finished = true;
+            cleanup();
+
+            const errorText = getErrorText(contentText);
+            const hasPartialOutput = assistantText.trim().length > 0 || toolCallBuffer.size > 0;
+
+            if (!hasPartialOutput && isRateLimitError(errorText)) {
+              reject(
+                new RetryableRateLimitError(
+                  "The model provider is temporarily rate limited.",
+                  extractRetryAfterMs(errorText),
+                  errorText
+                )
+              );
+            } else {
+              reject(
+                new UpstreamProviderError(
+                  hasPartialOutput
+                    ? "The model provider interrupted the response. Please try again."
+                    : "The model provider returned an error. Please try again.",
+                  errorText
+                )
+              );
+            }
+          }
+          return;
+        }
+
+        assistantText += contentText;
+        if (onToken) onToken(contentText);
+      }
 
       if (delta?.tool_calls) {
         for (const call of delta.tool_calls) {
           const entry = toolCallBuffer.get(call.index) ?? { arguments: "" };
           if (call.id) entry.id = call.id;
-          if (call.function?.name) entry.name = call.function.name;
+          if (call.function?.name) {
+            entry.name = sanitizeToolName(call.function.name, allowedToolNames);
+          }
           if (call.function?.arguments) entry.arguments += call.function.arguments;
           toolCallBuffer.set(call.index, entry);
         }
@@ -216,11 +1193,7 @@ export async function websocketChatStream(body, headers, onToken, abortSignal) {
       if (payload.choices?.[0]?.finish_reason && !finished) {
         finished = true;
         cleanup();
-        const toolCalls = [...toolCallBuffer.values()].map((t) => ({
-          id: t.id || `call_${crypto.randomUUID()}`,
-          type: "function",
-          function: { name: t.name, arguments: t.arguments },
-        }));
+        const toolCalls = serializeToolCalls(toolCallBuffer);
         resolve({ assistantText, toolCalls });
       }
     };
@@ -259,65 +1232,34 @@ export async function streamChat({
   history = [],
   userMessage,
   tools,
+  owner = null,
+  sessionName = "",
   accessToken,
   clientId,
+  webSearchLimit = null,
   onToken = () => {},
   onDone = () => {},
   onError = () => {},
   onToolCall = () => {},
   onNewAsset = () => {},
+  onDraftEdit = () => {},
   abortSignal,
 }) {
-
   const enabledTools = buildToolList(tools);
-
-  let normalizedUserMessage = userMessage;
-
-  if (Array.isArray(userMessage)) {
-
-    const hasImages = userMessage.some(item => item.type === "image_url");
-
-    if (hasImages) {
-
-      const textItems = userMessage.filter(
-        item => item.type === "text" && item.text?.trim()
-      );
-
-      if (textItems.length === 0) {
-        normalizedUserMessage = [
-          { type: "text", text: "[Image(s) attached]" },
-          ...userMessage.filter(item => item.type === "image_url"),
-        ];
-      }
-
-    } else {
-
-      normalizedUserMessage =
-        userMessage
-          .filter(b => b.type === "text")
-          .map(b => b.text)
-          .join("\n")
-          .trim() || "";
-
-    }
-  }
-
-  const hasUserMessage =
-      userMessage !== undefined &&
-      userMessage !== null &&
-      (typeof userMessage === "string" ? userMessage.trim() !== "" : Array.isArray(userMessage) && userMessage.length > 0);
-
-  const messages = [
-    { role: "system", content: SYSTEM_PROMPT },
-    ...history.map(normalizeMessage).filter(Boolean),
-  ];
-
-  if (hasUserMessage) {
-    messages.push({
-      role: "user",
-      content: normalizedUserMessage,
-    });
-  }
+  const [memories, systemPrompt] = await Promise.all([
+    owner ? memoryStore.list(owner).catch(() => []) : [],
+    owner?.type === "user"
+      ? systemPromptStore.getResolvedPrompt(owner.id)
+      : systemPromptStore.getDefaultPrompt(),
+  ]);
+  const baseMessages = buildBasePromptMessages({
+    sessionId,
+    history,
+    userMessage,
+    memories,
+    sessionName,
+    systemPrompt,
+  });
 
   const headers = {
     ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
@@ -325,108 +1267,129 @@ export async function streamChat({
   };
 
   try {
+    let assistantText = "";
+    let agentStep = 0;
+    let finished = false;
+    const workingMessages = [];
+    const allToolCalls = [];
+    const draftState = { text: "" };
+    const responseEdits = [];
+    const responseSegments = [];
+
+    while (!finished && agentStep < MAX_AGENT_STEPS) {
+      const effectiveMessages = buildModelMessages(baseMessages, workingMessages, sessionId);
+      const body = {
+        model: model || "lightning",
+        messages: effectiveMessages,
+        tools: enabledTools.length ? enabledTools : undefined,
+        stream: true,
+      };
 
-    const body = {
-      model: model || "lightning",
-      messages,
-      tools: enabledTools.length ? enabledTools : undefined,
-      stream: true,
-    };
-
-    let { assistantText, toolCalls } =
-      await websocketChatStream(body, headers, onToken, abortSignal);
-
-    if (toolCalls.length > 0) {
-
-      const toolResults = await processToolCalls(
-        null,
-        toolCalls,
-        tools,
-        accessToken,
-        clientId,
-        abortSignal,
-        onToolCall,
-        onNewAsset
+      const { assistantText: stepText, toolCalls } = await websocketChatStreamWithRetry(
+        body,
+        headers,
+        onToken,
+        abortSignal
       );
 
-      const followUpMessages = [
-        { role: "system", content: SYSTEM_PROMPT },
-        ...history.map(normalizeMessage).filter(Boolean),
-      ];
+      if (stepText) {
+        responseSegments.push({ type: "text", text: stepText });
+      }
+      assistantText += stepText;
+      draftState.text = assistantText;
+
+      if (toolCalls.length > 0) {
+        allToolCalls.push(...toolCalls);
+        responseSegments.push(
+          ...toolCalls.map((call) => ({
+            type: "tool_call",
+            callId: call.id,
+          }))
+        );
+        workingMessages.push({
+          role: "assistant",
+          content: stepText || "",
+          tool_calls: toolCalls,
+        });
 
-      if (hasUserMessage) {
-        followUpMessages.push({
-          role: "user",
-          content: normalizedUserMessage,
+        const { nextMessages } = await processToolCalls({
+          sessionId,
+          toolCalls,
+          tools,
+          owner,
+          accessToken,
+          clientId,
+          webSearchLimit,
+          abortSignal,
+          draftState,
+          onToolCall,
+          onNewAsset,
+          onDraftEdit(edit, text) {
+            responseEdits.push(edit);
+            onDraftEdit(edit, text);
+          },
         });
+        assistantText = draftState.text || assistantText;
+        workingMessages.push(...nextMessages);
+
+        agentStep++;
+        continue;
+      } else {
+        if (stepText) {
+          workingMessages.push({ role: "assistant", content: stepText });
+        }
+        finished = true;
       }
+    }
 
-      followUpMessages.push(
+    if (!finished) {
+      const finalMessages = [
+        ...buildModelMessages(baseMessages, workingMessages, sessionId),
         {
-          role: "assistant",
-          content: assistantText || "",
-          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+          role: "system",
+          content: "Tool-use budget is exhausted for this response. Do not call tools. Answer directly using the information already gathered. If something is still missing, briefly say what is missing without calling tools.",
         },
-        ...toolResults
-      );
+      ];
 
-      const followUpBody = {
-        model: model || "lightning",
-        messages: followUpMessages,
-        tools: enabledTools,
-        stream: true,
-      };
+      const { assistantText: finalStepText } = await websocketChatStreamWithRetry(
+        {
+          model: model || "lightning",
+          messages: finalMessages,
+          stream: true,
+        },
+        headers,
+        onToken,
+        abortSignal
+      );
 
-      let followUpAssistantText = "";
-      for (let attempt = 0; attempt < 2; attempt++) {
-        const followUp = await websocketChatStream(followUpBody, headers, onToken, abortSignal);
-        followUpAssistantText += followUp.assistantText;
-
-        // If the model returned new tool calls, process them and update the body
-        if (followUp.toolCalls.length > 0) {
-          const toolResults = await processToolCalls(
-            null,
-            followUp.toolCalls,
-            tools,
-            accessToken,
-            clientId,
-            abortSignal,
-            onToolCall,
-            onNewAsset
-          );
-          followUpMessages.push(...toolResults);
-
-          // Update body for another pass
-          followUpBody.messages = followUpMessages;
-        } else {
-          break; // no new tool calls, we’re done
-        }
+      if (finalStepText) {
+        responseSegments.push({ type: "text", text: finalStepText });
+        assistantText += finalStepText;
+        draftState.text = assistantText;
+        workingMessages.push({ role: "assistant", content: finalStepText });
       }
-      assistantText += followUpAssistantText;
+      finished = true;
+    }
+
+    if (!assistantText.trim()) {
+      assistantText = "I wasn’t able to finish that response cleanly. Please try again.";
     }
 
     const sessionName = extractSessionName(assistantText);
 
     if (typeof onDone === "function") {
-      onDone(assistantText, toolCalls, false, sessionName);
+      onDone(assistantText, allToolCalls, false, sessionName, responseEdits, responseSegments);
     }
 
-  } catch (err) {
+    clearPromptState(sessionId);
 
-    console.error("streamChat error:", err);
-
-    if (
-      err.name === "AbortError" ||
-      err.message === "AbortError"
-    ) {
-      if (typeof onDone === "function") {
-        onDone(null, null, true, null);
-      }
+  } catch (err) {
+    console.error("streamChat error:", err?.internalMessage || err);
+    clearPromptState(sessionId);
+    if (err.name === "AbortError" || err.message === "AbortError") {
+      if (typeof onDone === "function") onDone(null, null, true, null);
     } else {
-      console.error("streamChat error:", err);
-      if (typeof onError === "function") {
-        onError(String(err));
-      }
+      if (typeof onError === "function") onError(getPublicErrorMessage(err));
     }
   }
 }
@@ -436,8 +1399,22 @@ const VALID_ROLES = new Set(["system", "user", "assistant", "tool"]);
 function normalizeMessage(msg) {
   if (!VALID_ROLES.has(msg.role)) return null;
 
-  if (msg.role === "assistant" && msg.tool_calls) {
-    return { role: "assistant", content: "", tool_calls: msg.tool_calls };
+  if (msg.role === "assistant" && (msg.tool_calls || msg.toolCalls)) {
+    const normalizedToolCalls = (msg.tool_calls || normalizeStoredToolCalls(msg.toolCalls))
+      .map((call) => ({
+        ...call,
+        function: {
+          ...call.function,
+          name: sanitizeToolName(call.function?.name || call.name || "unknown_tool"),
+        },
+      }))
+      .filter((call) => call.function?.name);
+
+    return {
+      role: "assistant",
+      content: msg.content ?? "",
+      ...(normalizedToolCalls.length ? { tool_calls: normalizedToolCalls } : {}),
+    };
   }
   if (Array.isArray(msg.content)) {
     // If the array contains images, preserve the full array format
@@ -456,9 +1433,149 @@ function normalizeMessage(msg) {
 }
 
 function buildToolList(tools) {
-  if (!tools) return [];
+  const config = tools || {};
   const list = [];
-  if (tools.webSearch) {
+  list.push({
+    type: "function",
+    function: {
+      name: "list_prompt_resources",
+      description: "List the staged prompt resources, including omitted prompt text, attachments, images, and condensed history",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    },
+  });
+
+  list.push({
+    type: "function",
+    function: {
+      name: "read_prompt_chunk",
+      description: "Read an exact text chunk from a staged prompt resource",
+      parameters: {
+        type: "object",
+        properties: {
+          resource_id: { type: "string", description: "The resource id from list_prompt_resources" },
+          chunk_index: { type: "number", description: "Zero-based chunk index" },
+        },
+        required: ["resource_id", "chunk_index"]
+      },
+    },
+  });
+
+  list.push({
+    type: "function",
+    function: {
+      name: "load_prompt_images",
+      description: "Load staged images into the next model step in a smaller batch",
+      parameters: {
+        type: "object",
+        properties: {
+          resource_id: { type: "string", description: "The staged image resource id" },
+          indexes: { type: "array", items: { type: "number" }, description: "Zero-based image indexes to load" },
+          start_index: { type: "number", description: "Optional zero-based starting image index when indexes is omitted" },
+          count: { type: "number", description: "Optional number of images to load when indexes is omitted" },
+        },
+        required: ["resource_id"]
+      },
+    },
+  });
+
+  list.push({
+    type: "function",
+    function: {
+      name: "write_notes",
+      description: "Write notes to memory for later reasoning",
+      parameters: { type: "object", properties: { note: { type: "string" } }, required: ["note"] }
+    }
+  });
+  list.push({
+    type: "function",
+    function: {
+      name: "list_app_doc_sections",
+      description: "List the available sections of the app documentation so you can choose one relevant section to read.",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    },
+  });
+  list.push({
+    type: "function",
+    function: {
+      name: "read_app_doc_section",
+      description: "Read one specific app documentation section by section id or exact section title.",
+      parameters: {
+        type: "object",
+        properties: {
+          section_id: { type: "string", description: "The section id or exact title from list_app_doc_sections." },
+        },
+        required: ["section_id"],
+      },
+    },
+  });
+  list.push({
+    type: "function",
+    function: {
+      name: "list_memories",
+      description: "List the currently saved persistent memories for this user.",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    },
+  });
+  list.push({
+    type: "function",
+    function: {
+      name: "save_memory",
+      description: "Save a short persistent memory that may help in future chats. Keep it brief and only use this for durable user preferences or facts.",
+      parameters: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "A short durable memory, ideally one sentence or shorter." },
+        },
+        required: ["content"],
+      },
+    },
+  });
+  list.push({
+    type: "function",
+    function: {
+      name: "delete_memory",
+      description: "Delete a previously saved persistent memory when it is outdated or incorrect.",
+      parameters: {
+        type: "object",
+        properties: {
+          memory_id: { type: "string", description: "The memory id to delete." },
+        },
+        required: ["memory_id"],
+      },
+    },
+  });
+  list.push({
+    type: "function",
+    function: {
+      name: "edit_response_draft",
+      description: "Revise text that was already streamed to the user. Use this to correct or remove visible text that has already appeared.",
+      parameters: {
+        type: "object",
+        properties: {
+          operation: {
+            type: "string",
+            enum: ["replace_all", "replace_last_match", "delete_last_match", "delete_last_chars", "append", "clear"],
+          },
+          text: { type: "string", description: "Replacement text for replace_all or text to append." },
+          target_text: { type: "string", description: "Exact text to replace or delete for match-based operations." },
+          replacement_text: { type: "string", description: "Replacement text for replace_last_match." },
+          count: { type: "number", description: "Character count for delete_last_chars." },
+          reason: { type: "string", description: "Brief reason for the visible edit." },
+        },
+        required: ["operation"],
+      },
+    },
+  });
+  if (config.webSearch) {
     list.push({
       type: "function",
       function: {
@@ -484,7 +1601,7 @@ function buildToolList(tools) {
       },
     });
   }
-  if (tools.imageGen) {
+  if (config.imageGen) {
     list.push({
       type: "function",
       function: {
@@ -502,7 +1619,7 @@ function buildToolList(tools) {
       },
     });
   }
-  if (tools.videoGen) {
+  if (config.videoGen) {
     list.push({
       type: "function",
       function: {
@@ -522,7 +1639,7 @@ function buildToolList(tools) {
       },
     });
   }
-  if (tools.audioGen) {
+  if (config.audioGen) {
     list.push({
       type: "function",
       function: {
@@ -539,9 +1656,84 @@ function buildToolList(tools) {
   return list;
 }
 
-async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abortSignal, onToolCall, onNewAsset) {
-  const toolResults = [];
+function normalizeRequestedImageIndexes(args, resource) {
+  const explicitIndexes = Array.isArray(args.indexes)
+    ? [...new Set(args.indexes.map((value) => Number(value)).filter(Number.isInteger))]
+    : [];
+
+  const validExplicitIndexes = explicitIndexes.filter(
+    (index) => index >= 0 && index < resource.imageCount
+  );
+  if (validExplicitIndexes.length) return validExplicitIndexes;
+
+  const requestedStart = Number.isInteger(Number(args.start_index))
+    ? Number(args.start_index)
+    : resource.inlineImageCount || 0;
+  const requestedCount = Number.isInteger(Number(args.count))
+    ? Number(args.count)
+    : MAX_INLINE_IMAGES;
+
+  const indexes = [];
+  for (let i = 0; i < requestedCount; i++) {
+    const index = requestedStart + i;
+    if (index >= 0 && index < resource.imageCount) {
+      indexes.push(index);
+    }
+  }
+
+  return indexes;
+}
+
+function applyResponseDraftEdit(currentText, args = {}) {
+  const source = String(currentText || "");
+  const operation = args.operation;
+  switch (operation) {
+    case "replace_all":
+      return String(args.text || "");
+    case "append":
+      return source + String(args.text || "");
+    case "clear":
+      return "";
+    case "replace_last_match": {
+      const target = String(args.target_text || "");
+      if (!target) return source;
+      const idx = source.lastIndexOf(target);
+      if (idx === -1) return source;
+      return source.slice(0, idx) + String(args.replacement_text || "") + source.slice(idx + target.length);
+    }
+    case "delete_last_match": {
+      const target = String(args.target_text || "");
+      if (!target) return source;
+      const idx = source.lastIndexOf(target);
+      if (idx === -1) return source;
+      return source.slice(0, idx) + source.slice(idx + target.length);
+    }
+    case "delete_last_chars": {
+      const count = Math.max(0, Number(args.count) || 0);
+      return source.slice(0, Math.max(0, source.length - count));
+    }
+    default:
+      return source;
+  }
+}
+
+async function processToolCalls({
+  sessionId,
+  toolCalls,
+  tools,
+  owner,
+  accessToken,
+  clientId,
+  webSearchLimit,
+  abortSignal,
+  draftState,
+  onToolCall,
+  onNewAsset,
+  onDraftEdit,
+}) {
+  const nextMessages = [];
   const authHeaders = {};
+  const allowedToolNames = getAllowedToolNames(buildToolList(tools));
   if (accessToken) {
     authHeaders["Authorization"] = `Bearer ${accessToken}`;
   }
@@ -552,17 +1744,168 @@ async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abo
   for (const call of toolCalls) {
     let args;
     try { args = JSON.parse(call.function.arguments || "{}"); } catch { args = {}; }
+    const toolName = sanitizeToolName(call.function?.name, allowedToolNames);
+    if (toolName) {
+      call.function.name = toolName;
+    }
 
-    onToolCall({ id: call.id, name: call.function.name, state: "pending", args });
+    onToolCall({ id: call.id, name: toolName || call.function?.name, state: "pending", args });
 
     let result = "Tool completed.";
 
     try {
-      if (call.function.name === "ollama_search") {
-        result = await gradioSearch(args.query);
+      if (!toolName || !allowedToolNames.includes(toolName)) {
+        result = `Invalid tool name "${call.function?.name || "unknown"}".`;
+      }
+
+      else if (toolName === "list_prompt_resources") {
+        const state = getPromptState(sessionId);
+        result = JSON.stringify(buildPromptResourceManifest(state), null, 2);
+      }
+
+      else if (toolName === "read_prompt_chunk") {
+        const state = getPromptState(sessionId);
+        const chunkIndex = Number.isInteger(Number(args.chunk_index))
+          ? Number(args.chunk_index)
+          : Number(args.chunk_id);
+        const resourceId = args.resource_id || args.filename;
+        const resource = findPromptResource(state, resourceId);
+
+        if (!resource) {
+          result = `Prompt resource "${resourceId}" not found.`;
+        } else if (resource.kind === "images") {
+          result = `Resource "${resource.id}" contains images, not text. Use load_prompt_images instead.`;
+        } else if (!Number.isInteger(chunkIndex) || chunkIndex < 0 || chunkIndex >= resource.chunkCount) {
+          result = `Chunk ${chunkIndex} is out of range for resource "${resource.id}" (${resource.chunkCount} chunk(s)).`;
+        } else {
+          const chunk = resource.chunks[chunkIndex];
+          result = [
+            `Resource: ${resource.id}`,
+            `Name: ${resource.name}`,
+            `Kind: ${resource.kind}`,
+            `Chunk: ${chunk.index + 1}/${resource.chunkCount}`,
+            "",
+            chunk.text,
+          ].join("\n");
+        }
+      }
+
+      else if (toolName === "load_prompt_images") {
+        const state = getPromptState(sessionId);
+        const resource = findPromptResource(state, args.resource_id);
+
+        if (!resource) {
+          result = `Prompt image resource "${args.resource_id}" not found.`;
+        } else if (resource.kind !== "images") {
+          result = `Resource "${resource.id}" is not an image resource.`;
+        } else {
+          const indexes = normalizeRequestedImageIndexes(args, resource);
+          const selectedImages = indexes
+            .map((index) => resource.images[index]?.block)
+            .filter(Boolean);
+
+          if (!selectedImages.length) {
+            result = `No images were loaded from "${resource.id}".`;
+          } else {
+            result = `Loaded image indexes ${indexes.join(", ")} from "${resource.id}".`;
+            nextMessages.push({
+              role: "tool",
+              tool_call_id: call.id,
+              content: result,
+            });
+            nextMessages.push({
+              role: "user",
+              content: [
+                {
+                  type: "text",
+                  text: `Requested staged images from resource "${resource.id}" (${resource.name}), indexes ${indexes.join(", ")}.`,
+                },
+                ...selectedImages,
+              ],
+            });
+            onToolCall({ id: call.id, name: toolName, state: "resolved", result });
+            continue;
+          }
+        }
+      }
+
+      else if (toolName === "write_notes") {
+        appendAssistantNote(sessionId, args.note);
+        result = "Note stored for the rest of this response.";
+      }
+
+      else if (toolName === "list_app_doc_sections") {
+        const sections = await listAppDocSections();
+        result = JSON.stringify(sections, null, 2);
+      }
+
+      else if (toolName === "read_app_doc_section") {
+        const section = await readAppDocSection(args.section_id);
+        result = section
+          ? [`Section: ${section.title}`, `Section ID: ${section.id}`, "", section.content].join("\n")
+          : `Documentation section "${args.section_id}" was not found.`;
+      }
+
+      else if (toolName === "list_memories") {
+        const memories = owner ? await memoryStore.list(owner) : [];
+        result = JSON.stringify(memories, null, 2);
+      }
+
+      else if (toolName === "save_memory") {
+        const memory = owner
+          ? await memoryStore.create(owner, {
+              content: args.content,
+              sessionId,
+              source: "assistant",
+            })
+          : null;
+        result = memory
+          ? `Saved memory ${memory.id}: ${memory.content}`
+          : "Memory was empty or could not be saved.";
+      }
+
+      else if (toolName === "delete_memory") {
+        const ok = owner ? await memoryStore.delete(owner, args.memory_id) : false;
+        result = ok ? `Deleted memory ${args.memory_id}.` : `Memory ${args.memory_id} was not found.`;
       }
 
-      else if (call.function.name === "read_web_page") {
+      else if (toolName === "edit_response_draft") {
+        const before = draftState?.text || "";
+        const after = applyResponseDraftEdit(before, args);
+        if (draftState) draftState.text = after;
+        const edit = {
+          operation: args.operation,
+          reason: String(args.reason || "").trim() || "Model revised its draft.",
+          before,
+          after,
+          timestamp: Date.now(),
+        };
+        if (before !== after) {
+          onDraftEdit(edit, after);
+          result = [
+            `Draft updated. The visible response now has ${after.length} character(s).`,
+            "Visible draft:",
+            (after || "[empty]").slice(-4000),
+          ].join("\n\n");
+        } else {
+          result = "Draft edit made no visible change.";
+        }
+      }
+
+      else if (toolName === "ollama_search") {
+        if (webSearchLimit?.key && Number.isFinite(webSearchLimit.limit)) {
+          const usage = await consumeWebSearchUsage(webSearchLimit.key, webSearchLimit.limit);
+          if (!usage.allowed) {
+            result = `Web search limit reached for today. Free accounts can use ${usage.limit} web searches per day. Try again on ${usage.window} after the daily reset or upgrade to a paid plan.`;
+          } else {
+            result = await gradioSearch(args.query);
+          }
+        } else {
+          result = await gradioSearch(args.query);
+        }
+      }
+
+      else if (toolName === "read_web_page") {
         const { convert } = await import("html-to-text");
         const res = await fetch(args.url, { signal: abortSignal });
         if (!res.ok) {
@@ -577,7 +1920,7 @@ async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abo
         }
       }
 
-      else if (call.function.name === "generate_image") {
+      else if (toolName === "generate_image") {
         const body = { prompt: args.prompt };
         if (args.mode) body.mode = args.mode;
         if (args.image_urls?.length) body.image_urls = args.image_urls;
@@ -591,9 +1934,15 @@ async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abo
         if (res.ok) {
           const buf = await res.arrayBuffer();
           const ct = res.headers.get("content-type") || "image/png";
-          const b64 = Buffer.from(buf).toString("base64");
-          const dataUrl = `data:${ct};base64,${b64}`;
-          onNewAsset({ role: "image", content: dataUrl });
+          const stored = await mediaStore.storeBuffer(owner, {
+            name: `generated-image-${Date.now()}.${ct.includes("svg") ? "svg" : ct.split("/")[1] || "png"}`,
+            mimeType: ct,
+            buffer: Buffer.from(buf),
+            sessionId,
+            source: "assistant_generated",
+            kind: "image",
+          });
+          onNewAsset({ id: stored.id, role: "image", mimeType: ct, name: stored.name });
           result = "Image generated successfully and shown to the user.";
         } else if (res.status == 402) {
           result = "An upgraded plan is required for higher limits.";
@@ -604,7 +1953,7 @@ async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abo
         }
       }
 
-      else if (call.function.name === "generate_video") {
+      else if (toolName === "generate_video") {
         const body = { prompt: args.prompt };
         if (args.ratio) body.ratio = args.ratio;
         if (args.mode) body.mode = args.mode;
@@ -619,9 +1968,16 @@ async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abo
         });
         if (res.ok) {
           const buf = await res.arrayBuffer();
-          const b64 = Buffer.from(buf).toString("base64");
-          const dataUrl = `data:video/mp4;base64,${b64}`;
-          onNewAsset({ role: "video", content: dataUrl });
+          const contentType = res.headers.get("content-type") || "video/mp4";
+          const stored = await mediaStore.storeBuffer(owner, {
+            name: `generated-video-${Date.now()}.${contentType.split("/")[1] || "mp4"}`,
+            mimeType: contentType,
+            buffer: Buffer.from(buf),
+            sessionId,
+            source: "assistant_generated",
+            kind: "video",
+          });
+          onNewAsset({ id: stored.id, role: "video", mimeType: contentType, name: stored.name });
           result = "Video generated successfully and shown to the user.";
         } else if (res.status == 402) {
           result = "An upgraded plan is required for higher limits.";
@@ -632,7 +1988,7 @@ async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abo
         }
       }
 
-      else if (call.function.name === "generate_audio") {
+      else if (toolName === "generate_audio") {
         const res = await fetch(`${LIGHTNING_BASE}/gen/sfx`, {
           method: "POST",
           headers: { "Content-Type": "application/json", ...authHeaders },
@@ -641,9 +1997,16 @@ async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abo
         });
         if (res.ok) {
           const buf = await res.arrayBuffer();
-          const b64 = Buffer.from(buf).toString("base64");
-          const dataUrl = `data:audio/mpeg;base64,${b64}`;
-          onNewAsset({ role: "audio", content: dataUrl });
+          const contentType = res.headers.get("content-type") || "audio/mpeg";
+          const stored = await mediaStore.storeBuffer(owner, {
+            name: `generated-audio-${Date.now()}.${contentType.split("/")[1] || "mp3"}`,
+            mimeType: contentType,
+            buffer: Buffer.from(buf),
+            sessionId,
+            source: "assistant_generated",
+            kind: "audio",
+          });
+          onNewAsset({ id: stored.id, role: "audio", mimeType: contentType, name: stored.name });
           result = "Audio generated successfully and shown to the user.";
         } else if (res.status == 429) {
           result = "Too many requests. Try again later.";
@@ -655,14 +2018,14 @@ async function processToolCalls(ws, toolCalls, tools, accessToken, clientId, abo
       result = `Tool error: ${String(err)}`;
     }
 
-    onToolCall({ id: call.id, name: call.function.name, state: "resolved", result });
+    onToolCall({ id: call.id, name: toolName || call.function?.name, state: "resolved", result });
 
-    toolResults.push({
+    nextMessages.push({
       role: "tool",
       tool_call_id: call.id,
       content: typeof result === "string" ? result : JSON.stringify(result),
     });
   }
 
-  return toolResults;
-}
+  return { nextMessages, draftText: draftState?.text || "" };
+}

server/chatTrashStore.js

@@ -0,0 +1,149 @@
+import crypto from 'crypto';
+import path from 'path';
+import { loadEncryptedJson, saveEncryptedJson } from './cryptoUtils.js';
+
+const DATA_ROOT = '/data/deleted_chats';
+const INDEX_FILE = path.join(DATA_ROOT, 'index.json');
+const RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+
+const state = {
+  loaded: false,
+  index: {
+    deletedChats: {},
+  },
+};
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function ensureOwner(owner) {
+  if (!owner?.type || !owner?.id) throw new Error('Invalid deleted chat owner');
+  return owner;
+}
+
+async function ensureLoaded() {
+  if (state.loaded) return;
+  const stored = await loadEncryptedJson(INDEX_FILE);
+  state.index = {
+    deletedChats: stored?.deletedChats || {},
+  };
+  state.loaded = true;
+  await thisStore.purgeExpired();
+}
+
+async function saveIndex() {
+  await saveEncryptedJson(INDEX_FILE, state.index);
+}
+
+function matchesOwner(record, owner) {
+  return record.ownerType === owner.type && record.ownerId === owner.id;
+}
+
+function sanitize(record) {
+  return {
+    id: record.id,
+    originalSessionId: record.originalSessionId,
+    name: record.name,
+    deletedAt: record.deletedAt,
+    purgeAt: record.purgeAt,
+    created: record.created,
+  };
+}
+
+const thisStore = {
+  async add(owner, sessionSnapshot) {
+    ensureOwner(owner);
+    await ensureLoaded();
+
+    const sessionId = sessionSnapshot?.id;
+    if (!sessionId) return null;
+
+    for (const record of Object.values(state.index.deletedChats)) {
+      if (
+        record.originalSessionId === sessionId &&
+        record.ownerType === owner.type &&
+        record.ownerId === owner.id
+      ) {
+        record.sessionSnapshot = sessionSnapshot;
+        record.name = sessionSnapshot.name || 'Deleted Chat';
+        record.created = sessionSnapshot.created || Date.now();
+        record.deletedAt = nowIso();
+        record.purgeAt = new Date(Date.now() + RETENTION_MS).toISOString();
+        await saveIndex();
+        return sanitize(record);
+      }
+    }
+
+    const deleted = {
+      id: crypto.randomUUID(),
+      originalSessionId: sessionId,
+      ownerType: owner.type,
+      ownerId: owner.id,
+      name: sessionSnapshot.name || 'Deleted Chat',
+      created: sessionSnapshot.created || Date.now(),
+      sessionSnapshot,
+      deletedAt: nowIso(),
+      purgeAt: new Date(Date.now() + RETENTION_MS).toISOString(),
+    };
+    state.index.deletedChats[deleted.id] = deleted;
+    await saveIndex();
+    return sanitize(deleted);
+  },
+
+  async list(owner) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    return Object.values(state.index.deletedChats)
+      .filter((record) => matchesOwner(record, owner))
+      .sort((a, b) => new Date(b.deletedAt).getTime() - new Date(a.deletedAt).getTime())
+      .map(sanitize);
+  },
+
+  async restore(owner, ids) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const restored = [];
+    for (const id of ids || []) {
+      const record = state.index.deletedChats[id];
+      if (!record || !matchesOwner(record, owner)) continue;
+      restored.push(record.sessionSnapshot);
+      delete state.index.deletedChats[id];
+    }
+    if (restored.length) await saveIndex();
+    return restored;
+  },
+
+  async deleteForever(owner, ids) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const removed = [];
+    for (const id of ids || []) {
+      const record = state.index.deletedChats[id];
+      if (!record || !matchesOwner(record, owner)) continue;
+      delete state.index.deletedChats[id];
+      removed.push(id);
+    }
+    if (removed.length) await saveIndex();
+    return removed;
+  },
+
+  async purgeExpired() {
+    if (!state.loaded) return;
+    const now = Date.now();
+    let changed = false;
+    for (const [id, record] of Object.entries(state.index.deletedChats)) {
+      if (new Date(record.purgeAt).getTime() <= now) {
+        delete state.index.deletedChats[id];
+        changed = true;
+      }
+    }
+    if (changed) await saveIndex();
+  },
+};
+
+setInterval(() => {
+  thisStore.purgeExpired().catch((err) => console.error('chatTrashStore cleanup failed:', err));
+}, 6 * 60 * 60 * 1000);
+
+export const chatTrashStore = thisStore;

server/cryptoUtils.js

@@ -2,61 +2,135 @@ import crypto from 'crypto';
 import fs from 'fs/promises';
 import path from 'path';
 
+const JSON_FORMAT_VERSION = 2;
+const BINARY_FORMAT_VERSION = 1;
 const ALGORITHM = 'aes-256-gcm';
-const KEY_LENGTH = 32; // 256 bits
-const IV_LENGTH = 16; // 128 bits for GCM
-const AUTH_TAG_LENGTH = 16; // 128 bits
+const KEY_LENGTH = 32;
+const IV_LENGTH = 12;
+const AUTH_TAG_LENGTH = 16;
 
-// Derive key from environment variable
 function getKey() {
   const keyEnv = process.env.DATA_ENCRYPTION_KEY;
   if (!keyEnv) throw new Error('DATA_ENCRYPTION_KEY environment variable not set');
-  // Use SHA-256 to derive a 32-byte key from the env var
-  return crypto.createHash('sha256').update(keyEnv).digest();
+  return crypto.createHash('sha256').update(keyEnv).digest().subarray(0, KEY_LENGTH);
 }
 
-export function encryptJson(data) {
+function normalizeAad(aad = '') {
+  if (Buffer.isBuffer(aad)) return aad;
+  return Buffer.from(String(aad || ''), 'utf8');
+}
+
+export function encryptBuffer(buffer, aad = '') {
   const key = getKey();
   const iv = crypto.randomBytes(IV_LENGTH);
-  const cipher = crypto.createCipher(ALGORITHM, key);
-  cipher.setAAD(Buffer.from('')); // Optional AAD
-
-  let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
-  encrypted += cipher.final('hex');
-
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  const aadBuffer = normalizeAad(aad);
+  if (aadBuffer.length) cipher.setAAD(aadBuffer);
+  const encrypted = Buffer.concat([cipher.update(buffer), cipher.final()]);
   const authTag = cipher.getAuthTag();
   return {
-    iv: iv.toString('hex'),
+    version: BINARY_FORMAT_VERSION,
+    iv,
+    authTag,
     encrypted,
-    authTag: authTag.toString('hex'),
   };
 }
 
-export function decryptJson(encryptedData) {
+export function decryptBuffer(payload, aad = '') {
   const key = getKey();
-  const { iv, encrypted, authTag } = encryptedData;
-  const decipher = crypto.createDecipher(ALGORITHM, key);
-  decipher.setAuthTag(Buffer.from(authTag, 'hex'));
-  decipher.setAAD(Buffer.from('')); // Match AAD
+  const iv = Buffer.isBuffer(payload?.iv) ? payload.iv : Buffer.from(payload?.iv || '', 'hex');
+  const authTag = Buffer.isBuffer(payload?.authTag)
+    ? payload.authTag
+    : Buffer.from(payload?.authTag || '', 'hex');
+  const encrypted = Buffer.isBuffer(payload?.encrypted)
+    ? payload.encrypted
+    : Buffer.from(payload?.encrypted || '', 'hex');
+
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+  const aadBuffer = normalizeAad(aad);
+  if (aadBuffer.length) decipher.setAAD(aadBuffer);
+  decipher.setAuthTag(authTag);
+  return Buffer.concat([decipher.update(encrypted), decipher.final()]);
+}
 
-  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+export function packEncryptedBuffer(payload) {
+  const header = Buffer.allocUnsafe(1 + 1 + payload.iv.length + payload.authTag.length);
+  header.writeUInt8(payload.version || BINARY_FORMAT_VERSION, 0);
+  header.writeUInt8(payload.iv.length, 1);
+  payload.iv.copy(header, 2);
+  payload.authTag.copy(header, 2 + payload.iv.length);
+  return Buffer.concat([header, payload.encrypted]);
+}
+
+export function unpackEncryptedBuffer(buffer) {
+  const version = buffer.readUInt8(0);
+  if (version !== BINARY_FORMAT_VERSION) {
+    throw new Error(`Unsupported encrypted buffer version: ${version}`);
+  }
+  const ivLength = buffer.readUInt8(1);
+  const ivStart = 2;
+  const ivEnd = ivStart + ivLength;
+  const tagEnd = ivEnd + AUTH_TAG_LENGTH;
+  return {
+    version,
+    iv: buffer.subarray(ivStart, ivEnd),
+    authTag: buffer.subarray(ivEnd, tagEnd),
+    encrypted: buffer.subarray(tagEnd),
+  };
+}
+
+export async function writeEncryptedFile(filePath, buffer, aad = '') {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const payload = encryptBuffer(buffer, aad);
+  await fs.writeFile(filePath, packEncryptedBuffer(payload));
+}
+
+export async function readEncryptedFile(filePath, aad = '') {
+  const packed = await fs.readFile(filePath);
+  return decryptBuffer(unpackEncryptedBuffer(packed), aad);
+}
+
+function legacyDecryptJson(encryptedData) {
+  const key = getKey();
+  const decipher = crypto.createDecipher(ALGORITHM, key);
+  decipher.setAuthTag(Buffer.from(encryptedData.authTag, 'hex'));
+  let decrypted = decipher.update(encryptedData.encrypted, 'hex', 'utf8');
   decrypted += decipher.final('utf8');
   return JSON.parse(decrypted);
 }
 
-export async function saveEncryptedJson(filePath, data) {
-  const encrypted = encryptJson(data);
+export function encryptJson(data, aad = '') {
+  const payload = encryptBuffer(Buffer.from(JSON.stringify(data), 'utf8'), aad);
+  return {
+    version: JSON_FORMAT_VERSION,
+    iv: payload.iv.toString('hex'),
+    authTag: payload.authTag.toString('hex'),
+    encrypted: payload.encrypted.toString('hex'),
+  };
+}
+
+export function decryptJson(encryptedData, aad = '') {
+  if (!encryptedData) return null;
+  if ((encryptedData.version || 0) >= JSON_FORMAT_VERSION) {
+    const decrypted = decryptBuffer(encryptedData, aad);
+    return JSON.parse(decrypted.toString('utf8'));
+  }
+  return legacyDecryptJson(encryptedData);
+}
+
+export async function saveEncryptedJson(filePath, data, aad = '') {
+  const encrypted = encryptJson(data, aad);
   await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(encrypted));
+  await fs.writeFile(filePath, JSON.stringify(encrypted, null, 2), 'utf8');
 }
 
-export async function loadEncryptedJson(filePath) {
+export async function loadEncryptedJson(filePath, aad = '') {
   try {
     const content = await fs.readFile(filePath, 'utf8');
     const encrypted = JSON.parse(content);
-    return decryptJson(encrypted);
+    return decryptJson(encrypted, aad);
   } catch (err) {
-    if (err.code === 'ENOENT') return null; // File not found
+    if (err.code === 'ENOENT') return null;
     throw err;
   }
-}
+}

server/handleFeedback.js

@@ -0,0 +1,162 @@
+import path from 'path';
+import crypto from 'crypto';
+import { saveEncryptedJson, loadEncryptedJson } from './cryptoUtils.js';
+
+const DATA_DIR = '/data';
+const TICKETS_FILE = path.join(DATA_DIR, 'feedback_tickets.json');
+const FEEDBACK_AAD = 'feedback_tickets_v1';
+
+const MAX_TITLE_LENGTH = 100;
+const MAX_BODY_LENGTH = 10000;
+
+function generateTicketId() {
+  return `tkt_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+}
+
+function sanitizeString(value, maxLength) {
+  if (typeof value !== 'string') return '';
+  return value.trim().slice(0, maxLength);
+}
+
+async function loadTickets() {
+  const data = await loadEncryptedJson(TICKETS_FILE, FEEDBACK_AAD);
+  if (!data || !Array.isArray(data.tickets)) return { tickets: [] };
+  return data;
+}
+
+async function saveTickets(data) {
+  await saveEncryptedJson(TICKETS_FILE, data, FEEDBACK_AAD);
+}
+
+export function registerFeedbackRoutes(app, { requireAdminTurnstile, verifyLimiter, logAdminEvent, ADMIN_TOKEN, getRequestIp }) {
+
+  // POST /api/feedback/submit — public, no auth required
+  app.post('/api/feedback/submit', async (req, res) => {
+    try {
+      const type = req.body?.type === 'improvement' ? 'improvement' : 'issue';
+      const environment = type === 'issue'
+        ? (req.body?.environment === 'beta' ? 'beta' : 'production')
+        : null;
+
+      const title = sanitizeString(req.body?.title, MAX_TITLE_LENGTH);
+      const body = sanitizeString(req.body?.body, MAX_BODY_LENGTH);
+
+      if (!title) {
+        return res.status(400).json({ error: 'feedback:title_required', message: 'A title is required.' });
+      }
+      if (!body) {
+        return res.status(400).json({ error: 'feedback:body_required', message: 'A description is required.' });
+      }
+
+      const ticket = {
+        id: generateTicketId(),
+        type,
+        environment,
+        title,
+        body,
+        status: 'open',
+        submittedAt: new Date().toISOString(),
+        resolvedAt: null,
+        ip: getRequestIp(req),
+        userAgent: (req.headers['user-agent'] || '').slice(0, 200),
+      };
+
+      const data = await loadTickets();
+      data.tickets.push(ticket);
+      await saveTickets(data);
+
+      console.log(`[FEEDBACK] New ${type} ticket submitted: "${title.slice(0, 60)}" id=${ticket.id}`);
+
+      return res.json({ success: true, id: ticket.id });
+    } catch (err) {
+      console.error('feedback submit error', err);
+      return res.status(500).json({ error: 'feedback:server_error', message: 'Failed to submit ticket.' });
+    }
+  });
+
+  // GET /admin/feedback — list tickets, requires admin auth + turnstile
+  app.get('/admin/feedback', requireAdminTurnstile, verifyLimiter, async (req, res) => {
+    const token = req.query.token;
+    if (token !== ADMIN_TOKEN) {
+      logAdminEvent(req, 'feedback_list_denied', { reason: 'bad_token' });
+      return res.status(403).json({ error: 'Forbidden' });
+    }
+
+    try {
+      const data = await loadTickets();
+      const tickets = data.tickets.map(t => ({
+        id: t.id,
+        type: t.type,
+        environment: t.environment,
+        title: t.title,
+        body: t.body,
+        status: t.status,
+        submittedAt: t.submittedAt,
+        resolvedAt: t.resolvedAt,
+      }));
+      logAdminEvent(req, 'feedback_list_view', { count: tickets.length });
+      return res.json({ tickets });
+    } catch (err) {
+      console.error('feedback list error', err);
+      return res.status(500).json({ error: 'feedback:server_error' });
+    }
+  });
+
+  // POST /admin/feedback/:id/resolve — mark a ticket resolved
+  app.post('/admin/feedback/:id/resolve', requireAdminTurnstile, verifyLimiter, async (req, res) => {
+    const token = req.body?.token || req.query.token;
+    if (token !== ADMIN_TOKEN) {
+      logAdminEvent(req, 'feedback_resolve_denied', { reason: 'bad_token', ticketId: req.params.id });
+      return res.status(403).json({ error: 'Forbidden' });
+    }
+
+    try {
+      const data = await loadTickets();
+      const ticket = data.tickets.find(t => t.id === req.params.id);
+      if (!ticket) {
+        return res.status(404).json({ error: 'feedback:not_found' });
+      }
+
+      ticket.status = 'resolved';
+      ticket.resolvedAt = new Date().toISOString();
+      await saveTickets(data);
+
+      logAdminEvent(req, 'feedback_resolved', { ticketId: ticket.id, title: ticket.title.slice(0, 60) });
+      return res.json({ success: true, ticket: {
+        id: ticket.id, status: ticket.status, resolvedAt: ticket.resolvedAt
+      }});
+    } catch (err) {
+      console.error('feedback resolve error', err);
+      return res.status(500).json({ error: 'feedback:server_error' });
+    }
+  });
+
+  // POST /admin/feedback/:id/reopen — reopen a resolved ticket
+  app.post('/admin/feedback/:id/reopen', requireAdminTurnstile, verifyLimiter, async (req, res) => {
+    const token = req.body?.token || req.query.token;
+    if (token !== ADMIN_TOKEN) {
+      logAdminEvent(req, 'feedback_reopen_denied', { reason: 'bad_token', ticketId: req.params.id });
+      return res.status(403).json({ error: 'Forbidden' });
+    }
+
+    try {
+      const data = await loadTickets();
+      const ticket = data.tickets.find(t => t.id === req.params.id);
+      if (!ticket) {
+        return res.status(404).json({ error: 'feedback:not_found' });
+      }
+
+      ticket.status = 'open';
+      ticket.resolvedAt = null;
+      await saveTickets(data);
+
+      logAdminEvent(req, 'feedback_reopened', { ticketId: ticket.id });
+      return res.json({ success: true, ticket: {
+        id: ticket.id, status: ticket.status, resolvedAt: ticket.resolvedAt
+      }});
+    } catch (err) {
+      console.error('feedback reopen error', err);
+      return res.status(500).json({ error: 'feedback:server_error' });
+    }
+  });
+}

server/index.js

@@ -8,11 +8,13 @@ import { fileURLToPath } from 'url';
 import fetch from 'node-fetch';
 import rateLimit from 'express-rate-limit';
 import fs from 'fs';
-
+import { registerFeedbackRoutes } from './handleFeedback.js';
 import { handleWsMessage } from './wsHandler.js';
 import { sessionStore, initStoreConfig } from './sessionStore.js';
 import { SUPABASE_URL, SUPABASE_ANON_KEY } from './config.js';
 import { safeSend } from './helpers.js';
+import { verifySupabaseToken } from './auth.js';
+import { mediaStore } from './mediaStore.js';
 
 export { SUPABASE_URL, SUPABASE_ANON_KEY };
 export { LIGHTNING_BASE, PUBLIC_URL } from './config.js';
@@ -29,14 +31,131 @@ const GITHUB_REPO = 'incognitolm/InferencePort-Pages';
 const CDN_BASE = `https://cdn.jsdelivr.net/gh/${GITHUB_REPO}`;
 let latestSHA = null;
 const ADMIN_TOKEN = process.env.ADMIN_TOKEN || 'supersecret';
+const TURNSTILE_SITE_KEY = process.env.TURNSTILE_SITE_KEY || '0x4AAAAAAC1ZXKIhZ9Kdz8j9';
+const MAX_TEXT_UPLOAD_BYTES = 100 * 1024;
+
+const LOCAL_UI_DIR = [
+  process.env.UI_LOCAL_PATH,
+  path.resolve(__dirname, '..', '..', 'InferencePort-Pages'),
+  path.resolve(process.cwd(), '..', 'InferencePort-Pages'),
+].filter(Boolean).find((dir) => {
+  try {
+    return fs.existsSync(path.join(dir, 'index.html'));
+  } catch {
+    return false;
+  }
+}) || null;
 
 // Rate limiter for admin endpoints (5 attempts per IP per minute)
-const verifyLimiter = rateLimit({ windowMs: 60*1000, max: 5, standardHeaders: true, legacyHeaders: false });
+const verifyLimiter = rateLimit({
+  windowMs: 60 * 1000,
+  max: 5,
+  standardHeaders: true,
+  legacyHeaders: false,
+  handler: (req, res) => {
+    logAdminEvent(req, 'rate_limited');
+    res.status(429).json({ error: 'rate_limited' });
+  },
+});
 
 const DATA_DIR = "/data";
 const VERSION_FILE = path.join(DATA_DIR, 'version.json');
 const PUBLIC_URL = process.env.PUBLIC_URL || 'default';
 
+function getRequestIp(req) {
+  return (req.headers['x-forwarded-for'] || '').split(',')[0].trim()
+    || req.socket?.remoteAddress
+    || req.ip
+    || 'unknown';
+}
+
+function truncateForLog(value, max = 180) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function extensionFromName(name = '') {
+  const ext = path.extname(String(name || '')).toLowerCase();
+  return ext.startsWith('.') ? ext.slice(1) : ext;
+}
+
+function isTextLikeUpload(name = '', mimeType = '', kind = '') {
+  const normalizedKind = String(kind || '').toLowerCase();
+  const mime = String(mimeType || '').toLowerCase();
+  const ext = extensionFromName(name);
+  if (normalizedKind === 'text' || normalizedKind === 'rich_text') return true;
+  if (mime.startsWith('text/')) return true;
+  if (['application/json', 'application/javascript', 'application/xml'].includes(mime)) return true;
+  return ['txt', 'md', 'json', 'js', 'ts', 'css', 'py', 'html', 'htm', 'xml', 'csv', 'rtf'].includes(ext);
+}
+
+function getCookieMap(req) {
+  const cookies = (req.headers.cookie || '')
+    .split(';')
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .map((entry) => {
+      const idx = entry.indexOf('=');
+      if (idx === -1) return null;
+      return [entry.slice(0, idx), entry.slice(idx + 1)];
+    })
+    .filter(Boolean);
+  return Object.fromEntries(cookies);
+}
+
+function hasAdminTurnstile(req) {
+  return getCookieMap(req).admin_turnstile === '1';
+}
+
+function requireAdminTurnstile(req, res, next) {
+  if (hasAdminTurnstile(req)) return next();
+  logAdminEvent(req, 'blocked_missing_turnstile');
+  return res.status(403).json({ error: 'turnstile:required' });
+}
+
+function logAdminEvent(req, action, detail = null) {
+  const parts = [
+    `[ADMIN ${new Date().toISOString()}]`,
+    `action=${action}`,
+    `ip=${getRequestIp(req)}`,
+    `method=${req.method}`,
+    `path=${truncateForLog(req.originalUrl || req.url, 220)}`,
+  ];
+  const userAgent = truncateForLog(req.headers['user-agent'] || 'unknown', 140);
+  if (userAgent) parts.push(`ua="${userAgent}"`);
+  if (typeof detail === 'string' && detail.trim()) {
+    parts.push(detail.trim());
+  } else if (detail && typeof detail === 'object') {
+    Object.entries(detail).forEach(([key, value]) => {
+      if (value === undefined || value === null || value === '') return;
+      parts.push(`${key}=${JSON.stringify(String(value))}`);
+    });
+  }
+  console.log(parts.join(' | '));
+}
+
+function respondTextUploadTooLarge(res) {
+  return res.status(413).json({
+    error: 'media:text_too_large',
+    message: 'Text files must be 100 KB or smaller.',
+  });
+}
+
+async function verifyTurnstileToken(token, remoteIp) {
+  const secret = process.env.TURNSTILE_SECRET_KEY;
+  if (!token || !secret) throw new Error('Missing token or server not configured');
+  const params = new URLSearchParams();
+  params.append('secret', secret);
+  params.append('response', token);
+  if (remoteIp) params.append('remoteip', remoteIp);
+  const response = await fetch('https://challenges.cloudflare.com/turnstile/v0/siteverify', {
+    method: 'POST',
+    body: params,
+  });
+  return response.json();
+}
+
 
 function loadStoredSHA() {
   try {
@@ -98,6 +217,7 @@ function saveStoredSHA(sha) {
 
 app.use(express.json({ limit: '10mb' }));
 
+// --- API Turnstile Protection ---
 app.use('/api', (req, res, next) => {
   const exempt = ['/turnstile', '/health'];
   if (exempt.includes(req.path)) return next();
@@ -106,6 +226,45 @@ app.use('/api', (req, res, next) => {
   return res.status(403).json({ error: 'turnstile:required' });
 });
 
+registerFeedbackRoutes(app, {
+  requireAdminTurnstile,
+  verifyLimiter,
+  logAdminEvent,
+  ADMIN_TOKEN,
+  getRequestIp,
+});
+
+async function getRequestOwner(req) {
+  const authHeader = req.headers.authorization || '';
+  const accessToken = authHeader.startsWith('Bearer ') ? authHeader.slice(7).trim() : '';
+  if (accessToken) {
+    const user = await verifySupabaseToken(accessToken);
+    if (user) return { owner: { type: 'user', id: user.id }, accessToken };
+  }
+
+  const tempId = String(req.headers['x-temp-id'] || req.query.tempId || '').trim();
+  if (tempId) {
+    sessionStore.initTemp(tempId);
+    return { owner: { type: 'guest', id: tempId }, accessToken: null };
+  }
+  return null;
+}
+
+async function requireRequestOwner(req, res) {
+  const resolved = await getRequestOwner(req);
+  if (!resolved?.owner) {
+    res.status(401).json({ error: 'auth:required' });
+    return null;
+  }
+  return resolved;
+}
+
+function requireSignedInMediaOwner(resolved, res, message = 'Sign in to upload files.') {
+  if (resolved?.owner?.type === 'user') return true;
+  res.status(403).json({ error: 'media:auth_required', message });
+  return false;
+}
+
 app.get('/health', (_req,res) => res.json({ok:true}));
 
 app.get('/api/share/:token', async (req,res) => {
@@ -123,17 +282,237 @@ app.get('/api/share/:token', async (req,res) => {
   } catch { res.status(500).json({error:'Server error'}); }
 });
 
+app.get('/api/media', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  try {
+    const result = await mediaStore.list(resolved.owner, {
+      view: req.query.view === 'trash' ? 'trash' : 'active',
+      parentId: req.query.parentId ? String(req.query.parentId) : null,
+    });
+    res.json(result);
+  } catch (err) {
+    console.error('media list error', err);
+    res.status(500).json({ error: 'media:list_failed' });
+  }
+});
+
+app.post('/api/media/upload', express.raw({ type: () => true, limit: '100mb' }), async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to upload files.')) return;
+  try {
+    const name = decodeURIComponent(String(req.headers['x-file-name'] || 'upload.bin'));
+    const mimeType = String(req.headers['x-mime-type'] || 'application/octet-stream');
+    const parentId = req.headers['x-parent-id'] ? String(req.headers['x-parent-id']) : null;
+    const sessionId = req.headers['x-session-id'] ? String(req.headers['x-session-id']) : null;
+    const kindHeader = req.headers['x-file-kind'] ? String(req.headers['x-file-kind']) : null;
+    const buffer = Buffer.isBuffer(req.body) ? req.body : Buffer.from(req.body || []);
+    if (isTextLikeUpload(name, mimeType, kindHeader) && buffer.byteLength > MAX_TEXT_UPLOAD_BYTES) {
+      return respondTextUploadTooLarge(res);
+    }
+    const item = await mediaStore.storeBuffer(resolved.owner, {
+      name,
+      mimeType,
+      buffer,
+      parentId,
+      sessionId,
+      source: 'user_upload',
+      kind: kindHeader || null,
+    });
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ item, usage });
+  } catch (err) {
+    console.error('media upload error', err);
+    res.status(err.status || 500).json({
+      error: err.code || 'media:upload_failed',
+      message: err.message || 'Upload failed',
+      usage: err.usage || null,
+    });
+  }
+});
+
+app.post('/api/media/folders', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to create folders.')) return;
+  try {
+    const item = await mediaStore.createFolder(resolved.owner, {
+      name: req.body?.name || 'New Folder',
+      parentId: req.body?.parentId || null,
+    });
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ item, usage });
+  } catch (err) {
+    console.error('media create folder error', err);
+    res.status(500).json({ error: 'media:create_folder_failed' });
+  }
+});
+
+app.post('/api/media/documents', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to create documents.')) return;
+  try {
+    const richText = !!req.body?.richText;
+    const content = String(req.body?.content || '');
+    if (Buffer.byteLength(content, 'utf8') > MAX_TEXT_UPLOAD_BYTES) {
+      return respondTextUploadTooLarge(res);
+    }
+    const item = await mediaStore.createDocument(resolved.owner, {
+      name: req.body?.name,
+      parentId: req.body?.parentId || null,
+      richText,
+      content,
+      source: 'user_upload',
+      sessionId: req.body?.sessionId || null,
+    });
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ item, usage });
+  } catch (err) {
+    console.error('media create document error', err);
+    res.status(err.status || 500).json({
+      error: err.code || 'media:create_document_failed',
+      message: err.message || 'Document creation failed',
+      usage: err.usage || null,
+    });
+  }
+});
+
+app.post('/api/media/move', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to move files.')) return;
+  try {
+    const items = await mediaStore.move(resolved.owner, req.body?.ids || [], req.body?.parentId || null);
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ items, usage });
+  } catch (err) {
+    console.error('media move error', err);
+    res.status(500).json({ error: 'media:move_failed' });
+  }
+});
+
+app.post('/api/media/trash', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  try {
+    const items = await mediaStore.moveToTrash(resolved.owner, req.body?.ids || []);
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ items, usage });
+  } catch (err) {
+    console.error('media trash error', err);
+    res.status(500).json({ error: 'media:trash_failed' });
+  }
+});
+
+app.post('/api/media/restore', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to restore files.')) return;
+  try {
+    const items = await mediaStore.restore(resolved.owner, req.body?.ids || []);
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ items, usage });
+  } catch (err) {
+    console.error('media restore error', err);
+    res.status(500).json({ error: 'media:restore_failed' });
+  }
+});
+
+app.post('/api/media/deleteForever', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  try {
+    const ids = await mediaStore.deleteForever(resolved.owner, req.body?.ids || []);
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ ids, usage });
+  } catch (err) {
+    console.error('media delete forever error', err);
+    res.status(500).json({ error: 'media:delete_failed' });
+  }
+});
+
+app.get('/api/media/:id/text', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  try {
+    const loaded = await mediaStore.readText(resolved.owner, req.params.id);
+    if (!loaded) return res.status(404).json({ error: 'media:not_found' });
+    res.json({ item: loaded.entry, content: loaded.text });
+  } catch (err) {
+    console.error('media read text error', err);
+    res.status(500).json({ error: 'media:read_failed' });
+  }
+});
+
+app.put('/api/media/:id/text', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to edit files.')) return;
+  try {
+    const buffer = Buffer.from(String(req.body?.content || ''), 'utf8');
+    if (buffer.byteLength > MAX_TEXT_UPLOAD_BYTES) {
+      return respondTextUploadTooLarge(res);
+    }
+    const item = await mediaStore.updateContent(resolved.owner, req.params.id, {
+      buffer,
+      mimeType: req.body?.mimeType || null,
+      kind: req.body?.richText ? 'rich_text' : null,
+      name: req.body?.name || null,
+    });
+    if (!item) return res.status(404).json({ error: 'media:not_found' });
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ item, usage });
+  } catch (err) {
+    console.error('media update text error', err);
+    res.status(err.status || 500).json({
+      error: err.code || 'media:update_failed',
+      message: err.message || 'Update failed',
+      usage: err.usage || null,
+    });
+  }
+});
+
+app.post('/api/media/:id/rename', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to rename files.')) return;
+  try {
+    const name = String(req.body?.name || '').trim();
+    if (!name) return res.status(400).json({ error: 'media:name_required', message: 'A file name is required.' });
+    const item = await mediaStore.rename(resolved.owner, req.params.id, name);
+    if (!item) return res.status(404).json({ error: 'media:not_found' });
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ item, usage });
+  } catch (err) {
+    console.error('media rename error', err);
+    res.status(500).json({ error: 'media:rename_failed', message: err.message || 'Rename failed' });
+  }
+});
+
+app.get('/api/media/:id/content', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  try {
+    const loaded = await mediaStore.readBuffer(resolved.owner, req.params.id);
+    if (!loaded) return res.status(404).json({ error: 'media:not_found' });
+    res.setHeader('Content-Type', loaded.entry.mimeType || 'application/octet-stream');
+    res.setHeader('Cache-Control', 'private, max-age=60');
+    if (req.query.download === '1') {
+      res.setHeader('Content-Disposition', `attachment; filename="${loaded.entry.name}"`);
+    }
+    res.send(loaded.buffer);
+  } catch (err) {
+    console.error('media read binary error', err);
+    res.status(500).json({ error: 'media:read_failed' });
+  }
+});
+
 app.post('/api/turnstile', async (req,res)=>{
   try{
     const token = req.body?.token;
-    const secret = process.env.TURNSTILE_SECRET_KEY;
-    if(!token||!secret) return res.status(400).json({error:'Missing token or server not configured'});
-    const params = new URLSearchParams();
-    params.append('secret',secret);
-    params.append('response',token);
-    if(req.ip) params.append('remoteip',req.ip);
-    const r = await fetch('https://challenges.cloudflare.com/turnstile/v0/siteverify',{method:'POST',body:params});
-    const j = await r.json();
+    const j = await verifyTurnstileToken(token, getRequestIp(req));
     if(j?.success){
       res.cookie('turnstile','1',{ maxAge:24*3600*1000, path:'/', sameSite:'lax'});
       return res.json({success:true});
@@ -163,7 +542,10 @@ if (!latestSHA) {
   console.log(`[${PUBLIC_URL}] Using stored SHA: ${latestSHA}`);
 }
 
+// --- Admin endpoints ---
 app.get('/admin.html', async (req, res) => {
+  logAdminEvent(req, 'page_view');
+  if (serveLocalUiFile('/admin.html', res)) return;
   if (!latestSHA) return res.status(500).send('Server not ready');
 
   const url = `${CDN_BASE}@${latestSHA}/admin.html`;
@@ -181,28 +563,90 @@ app.get('/admin.html', async (req, res) => {
   }
 });
 
-app.get('/admin/verify',verifyLimiter,(req,res)=>{
+app.get('/admin/config', (req, res) => {
+  logAdminEvent(req, 'config_view', { verified: hasAdminTurnstile(req) });
+  res.json({
+    siteKey: TURNSTILE_SITE_KEY || null,
+    verified: hasAdminTurnstile(req),
+  });
+});
+
+app.post('/admin/turnstile', async (req, res) => {
+  try {
+    const token = req.body?.token;
+    const result = await verifyTurnstileToken(token, getRequestIp(req));
+    if (!result?.success) {
+      logAdminEvent(req, 'turnstile_failed', {
+        errorCodes: Array.isArray(result?.['error-codes']) ? result['error-codes'].join(',') : '',
+      });
+      return res.status(403).json({ error: 'Verification failed' });
+    }
+    res.cookie('admin_turnstile', '1', { maxAge: 2 * 3600 * 1000, path: '/', sameSite: 'lax' });
+    logAdminEvent(req, 'turnstile_verified');
+    return res.json({ success: true });
+  } catch (err) {
+    console.error('admin turnstile verify', err);
+    logAdminEvent(req, 'turnstile_error', { message: err.message || 'unknown' });
+    return res.status(500).json({ error: err.message || 'Server error' });
+  }
+});
+
+app.get('/admin/verify', requireAdminTurnstile, verifyLimiter, (req,res)=>{
   const token = req.query.token;
-  res.json({success: token===ADMIN_TOKEN});
+  const success = token===ADMIN_TOKEN;
+  logAdminEvent(req, success ? 'login_success' : 'login_failed', {
+    turnstile: hasAdminTurnstile(req),
+    tokenProvided: !!token,
+  });
+  res.json({success});
 });
 
-app.get('/admin/refresh', verifyLimiter, async (req, res) => {
+app.get('/admin/refresh', requireAdminTurnstile, verifyLimiter, async (req, res) => {
   const token = req.query.token;
-  if (token !== ADMIN_TOKEN) return res.status(403).send('Forbidden');
+  if (token !== ADMIN_TOKEN) {
+    logAdminEvent(req, 'refresh_denied', { reason: 'bad_token' });
+    return res.status(403).send('Forbidden');
+  }
 
   const sha = req.query.sha?.trim();
   if (sha) {
-    if (!/^[0-9a-f]{7,40}$/.test(sha)) return res.status(400).send('Invalid SHA');
+    if (!/^[0-9a-f]{7,40}$/.test(sha)) {
+      logAdminEvent(req, 'set_sha_invalid', { requestedSha: sha });
+      return res.status(400).send('Invalid SHA');
+    }
     latestSHA = sha;
     saveStoredSHA(latestSHA);
+    logAdminEvent(req, 'set_sha', { requestedSha: latestSHA });
     console.log(`[${PUBLIC_URL}] Manual SHA set by admin: ${latestSHA}`);
     return res.send(`Version set to commit ${latestSHA}`);
   }
 
   await fetchLatestSHA();
+  logAdminEvent(req, 'refresh_latest', { resolvedSha: latestSHA });
   res.send(`Latest version refreshed: ${latestSHA}`);
 });
 
+app.get('/admin/status', requireAdminTurnstile, verifyLimiter, async (req, res) => {
+  const token = req.query.token;
+  if (token !== ADMIN_TOKEN) {
+    logAdminEvent(req, 'status_denied', { reason: 'bad_token' });
+    return res.status(403).json({ error: 'Forbidden' });
+  }
+  logAdminEvent(req, 'status_view', {
+    currentSha: latestSHA,
+    servingMode: LOCAL_UI_DIR ? 'local-ui' : 'cdn',
+  });
+  res.json({
+    publicUrl: PUBLIC_URL,
+    currentSha: latestSHA,
+    servingMode: LOCAL_UI_DIR ? 'local-ui' : 'cdn',
+    localUiDir: LOCAL_UI_DIR,
+    repo: GITHUB_REPO,
+    uiSource: LOCAL_UI_DIR ? 'Local InferencePort-Pages checkout is active' : 'Serving from CDN SHA',
+  });
+});
+
+// --- MIME type helper ---
 function getMimeType(filePath){
   const ext = path.extname(filePath).toLowerCase();
   switch(ext){
@@ -220,10 +664,31 @@ function getMimeType(filePath){
   }
 }
 
+function resolveLocalUiFile(filePath) {
+  if (!LOCAL_UI_DIR) return null;
+  const resolvedRoot = path.resolve(LOCAL_UI_DIR);
+  const relativePath = String(filePath || '/index.html').replace(/^[/\\]+/, '');
+  const resolvedFile = path.resolve(resolvedRoot, relativePath);
+  if (resolvedFile !== resolvedRoot && !resolvedFile.startsWith(`${resolvedRoot}${path.sep}`)) return null;
+  if (!fs.existsSync(resolvedFile) || fs.statSync(resolvedFile).isDirectory()) return null;
+  return resolvedFile;
+}
+
+function serveLocalUiFile(filePath, res) {
+  const resolvedFile = resolveLocalUiFile(filePath);
+  if (!resolvedFile) return false;
+  res.setHeader('Content-Type', getMimeType(resolvedFile));
+  res.send(fs.readFileSync(resolvedFile));
+  return true;
+}
+
+// Hybrid serving: everything via latest SHA (auto-refresh / manual refresh)
 app.get('*', async (req,res)=>{
   if(req.path.startsWith('/api/')) return res.status(404).send('Not found');
 
+  // All client files are fetched from latest SHA
   const filePath = req.path === '/' ? '/index.html' : req.path;
+  if (serveLocalUiFile(filePath, res)) return;
   const url = `${CDN_BASE}@${latestSHA}${filePath}`;
 
   try{
@@ -233,6 +698,7 @@ app.get('*', async (req,res)=>{
     const mimeType = getMimeType(filePath);
     res.setHeader('Content-Type', mimeType);
 
+    // Stream text files; redirect others (images/fonts) optional
     if(mimeType.startsWith('text') || mimeType==='application/javascript' || mimeType==='application/json'){
       const text = await response.text();
       res.send(text);
@@ -246,6 +712,7 @@ app.get('*', async (req,res)=>{
   }
 });
 
+// --- WebSocket ---
 const httpServer = createServer(app);
 const wss = new WebSocketServer({server:httpServer,path:'/ws'});
 
@@ -270,4 +737,4 @@ wss.on('connection',(ws,req)=>{
   safeSend(ws,{type:'connected', tempId:wsClients.get(ws)?.tempId});
 });
 
-httpServer.listen(PORT,'0.0.0.0',()=>console.log(`Running on port ${PORT}`));
+httpServer.listen(PORT,'0.0.0.0',()=>console.log(`Running on port ${PORT}`));

server/mediaStore.js

@@ -0,0 +1,517 @@
+import crypto from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+import { loadEncryptedJson, saveEncryptedJson, readEncryptedFile, writeEncryptedFile } from './cryptoUtils.js';
+
+const DATA_ROOT = '/data/media';
+const INDEX_FILE = path.join(DATA_ROOT, 'index.json');
+const BLOBS_DIR = path.join(DATA_ROOT, 'blobs');
+const TRASH_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const GUEST_RETENTION_MS = 24 * 60 * 60 * 1000;
+const MEDIA_QUOTA_BYTES = 5 * 1024 * 1024 * 1024;
+
+const state = {
+  loaded: false,
+  index: {
+    entries: {},
+  },
+};
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function ownerKey(owner) {
+  return `${owner.type}:${owner.id}`;
+}
+
+function ensureOwner(owner) {
+  if (!owner?.type || !owner?.id) throw new Error('Invalid media owner');
+  return owner;
+}
+
+function normalizeName(name, fallback = 'Untitled') {
+  const clean = String(name || '').trim().replace(/[\\/:*?"<>|]+/g, '_');
+  return clean || fallback;
+}
+
+function extensionFromName(name = '') {
+  const ext = path.extname(String(name || '')).toLowerCase();
+  return ext.startsWith('.') ? ext.slice(1) : ext;
+}
+
+function inferKind(name, mimeType = '') {
+  const mime = String(mimeType || '').toLowerCase();
+  const ext = extensionFromName(name);
+  if (mime.startsWith('image/') || ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'].includes(ext)) return 'image';
+  if (mime.startsWith('video/') || ['mp4', 'webm', 'mov'].includes(ext)) return 'video';
+  if (mime.startsWith('audio/') || ['mp3', 'wav', 'ogg', 'm4a'].includes(ext)) return 'audio';
+  if (mime === 'text/html' || ['html', 'htm'].includes(ext)) return 'rich_text';
+  if (mime.startsWith('text/') || ['txt', 'md', 'json', 'js', 'ts', 'css', 'py', 'html', 'xml', 'csv', 'rtf'].includes(ext)) return 'text';
+  return 'file';
+}
+
+function guessMimeType(name, fallbackKind = 'file') {
+  const ext = extensionFromName(name);
+  switch (ext) {
+    case 'txt': return 'text/plain';
+    case 'md': return 'text/markdown';
+    case 'json': return 'application/json';
+    case 'html':
+    case 'htm': return 'text/html';
+    case 'css': return 'text/css';
+    case 'js': return 'application/javascript';
+    case 'ts': return 'text/plain';
+    case 'svg': return 'image/svg+xml';
+    case 'png': return 'image/png';
+    case 'jpg':
+    case 'jpeg': return 'image/jpeg';
+    case 'gif': return 'image/gif';
+    case 'webp': return 'image/webp';
+    case 'mp4': return 'video/mp4';
+    case 'webm': return 'video/webm';
+    case 'mp3': return 'audio/mpeg';
+    case 'wav': return 'audio/wav';
+    case 'ogg': return 'audio/ogg';
+    case 'csv': return 'text/csv';
+    default:
+      if (fallbackKind === 'rich_text') return 'text/html';
+      if (fallbackKind === 'text') return 'text/plain';
+      return 'application/octet-stream';
+  }
+}
+
+async function ensureLoaded() {
+  if (state.loaded) return;
+  const stored = await loadEncryptedJson(INDEX_FILE);
+  state.index = {
+    entries: stored?.entries || {},
+  };
+  state.loaded = true;
+  await purgeExpiredInternal();
+}
+
+async function saveIndex() {
+  await saveEncryptedJson(INDEX_FILE, state.index);
+}
+
+function getEntry(id) {
+  return state.index.entries[id] || null;
+}
+
+function canAccess(entry, owner) {
+  return !!entry && entry.ownerType === owner.type && entry.ownerId === owner.id;
+}
+
+function sanitizeEntry(entry) {
+  return {
+    id: entry.id,
+    type: entry.type,
+    name: entry.name,
+    parentId: entry.parentId || null,
+    ownerType: entry.ownerType,
+    ownerId: entry.ownerId,
+    mimeType: entry.mimeType || null,
+    kind: entry.kind || null,
+    size: entry.size || 0,
+    source: entry.source || null,
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt,
+    trashedAt: entry.trashedAt || null,
+    purgeAt: entry.purgeAt || null,
+    sessionIds: entry.sessionIds || [],
+    deletedByAssistant: !!entry.deletedByAssistant,
+  };
+}
+
+function blobPathFor(id) {
+  return path.join(BLOBS_DIR, `${id}.bin`);
+}
+
+function buildAad(entry) {
+  return `media:${entry.id}:${entry.ownerType}:${entry.ownerId}`;
+}
+
+function isOwnedFile(entry, owner) {
+  return entry?.type === 'file' && entry.ownerType === owner.type && entry.ownerId === owner.id;
+}
+
+function getChildren(owner, parentId, includeTrash = true) {
+  return Object.values(state.index.entries).filter((entry) =>
+    entry.ownerType === owner.type &&
+    entry.ownerId === owner.id &&
+    (entry.parentId || null) === (parentId || null) &&
+    (includeTrash || !entry.trashedAt)
+  );
+}
+
+function collectDescendantIds(owner, rootId, acc = new Set()) {
+  acc.add(rootId);
+  const children = getChildren(owner, rootId, true);
+  for (const child of children) {
+    collectDescendantIds(owner, child.id, acc);
+  }
+  return [...acc];
+}
+
+function resolveParentFolder(owner, parentId) {
+  if (!parentId) return null;
+  const parent = getEntry(parentId);
+  if (!parent || !canAccess(parent, owner) || parent.type !== 'folder') return null;
+  return parent.id;
+}
+
+function wouldCreateCycle(owner, entryId, candidateParentId) {
+  let currentId = candidateParentId || null;
+  while (currentId) {
+    if (currentId === entryId) return true;
+    const current = getEntry(currentId);
+    if (!current || !canAccess(current, owner)) return false;
+    currentId = current.parentId || null;
+  }
+  return false;
+}
+
+function createQuotaError(owner, usage) {
+  const err = new Error('Cloud storage limit reached. Delete files or empty trash to free space.');
+  err.code = 'media:quota_exceeded';
+  err.status = 413;
+  err.usage = usage || null;
+  err.owner = owner;
+  return err;
+}
+
+function computeUsage(owner) {
+  const files = Object.values(state.index.entries).filter((entry) => isOwnedFile(entry, owner));
+  const totalBytes = files.reduce((sum, entry) => sum + (entry.size || 0), 0);
+  const trashBytes = files.reduce((sum, entry) => sum + (entry.trashedAt ? (entry.size || 0) : 0), 0);
+  const activeBytes = totalBytes - trashBytes;
+  const quotaBytes = MEDIA_QUOTA_BYTES;
+  return {
+    quotaBytes,
+    totalBytes,
+    activeBytes,
+    trashBytes,
+    remainingBytes: Math.max(0, quotaBytes - totalBytes),
+    percentUsed: quotaBytes > 0 ? Math.min(100, (totalBytes / quotaBytes) * 100) : 0,
+    fileCount: files.length,
+    trashFileCount: files.filter((entry) => !!entry.trashedAt).length,
+  };
+}
+
+function assertQuotaAvailable(owner, additionalBytes = 0) {
+  const usage = computeUsage(owner);
+  if ((usage.totalBytes + Math.max(0, additionalBytes)) > usage.quotaBytes) {
+    throw createQuotaError(owner, usage);
+  }
+  return usage;
+}
+
+async function purgeEntry(id) {
+  const entry = getEntry(id);
+  if (!entry) return;
+  if (entry.type === 'file') {
+    await fs.rm(blobPathFor(id), { force: true }).catch(() => {});
+  }
+  delete state.index.entries[id];
+}
+
+async function purgeExpiredInternal() {
+  const now = Date.now();
+  let changed = false;
+  for (const entry of Object.values(state.index.entries)) {
+    const shouldPurge =
+      (entry.purgeAt && new Date(entry.purgeAt).getTime() <= now) ||
+      (entry.expiresAt && new Date(entry.expiresAt).getTime() <= now);
+    if (!shouldPurge) continue;
+    for (const id of collectDescendantIds({ type: entry.ownerType, id: entry.ownerId }, entry.id)) {
+      await purgeEntry(id);
+    }
+    changed = true;
+  }
+  if (changed) await saveIndex();
+}
+
+setInterval(() => {
+  purgeExpiredInternal().catch((err) => console.error('mediaStore cleanup failed:', err));
+}, 6 * 60 * 60 * 1000);
+
+export const mediaStore = {
+  async list(owner, { view = 'active', parentId = null } = {}) {
+    ensureOwner(owner);
+    await ensureLoaded();
+
+    const includeTrash = view === 'trash';
+    const items = getChildren(owner, parentId, true)
+      .filter((entry) => includeTrash ? !!entry.trashedAt : !entry.trashedAt)
+      .sort((a, b) => {
+        if (a.type !== b.type) return a.type === 'folder' ? -1 : 1;
+        return new Date(b.updatedAt || b.createdAt).getTime() - new Date(a.updatedAt || a.createdAt).getTime();
+      })
+      .map(sanitizeEntry);
+
+    const breadcrumbs = [];
+    let currentId = parentId;
+    while (currentId) {
+      const entry = getEntry(currentId);
+      if (!entry || !canAccess(entry, owner)) break;
+      breadcrumbs.unshift({ id: entry.id, name: entry.name });
+      currentId = entry.parentId || null;
+    }
+
+    return { items, breadcrumbs, usage: computeUsage(owner) };
+  },
+
+  async get(owner, id) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const entry = getEntry(id);
+    if (!canAccess(entry, owner)) return null;
+    return sanitizeEntry(entry);
+  },
+
+  async storeBuffer(owner, {
+    name,
+    mimeType,
+    buffer,
+    parentId = null,
+    sessionId = null,
+    source = 'upload',
+    kind = null,
+    deletedByAssistant = false,
+  }) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    assertQuotaAvailable(owner, Buffer.byteLength(buffer));
+
+    const entryId = crypto.randomUUID();
+    const resolvedParentId = resolveParentFolder(owner, parentId);
+    const fileName = normalizeName(name, 'Untitled');
+    const inferredKind = kind || inferKind(fileName, mimeType);
+    const entry = {
+      id: entryId,
+      type: 'file',
+      name: fileName,
+      ownerType: owner.type,
+      ownerId: owner.id,
+      mimeType: mimeType || guessMimeType(fileName, inferredKind),
+      kind: inferredKind,
+      size: buffer.byteLength,
+      parentId: resolvedParentId,
+      source,
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+      trashedAt: null,
+      purgeAt: null,
+      sessionIds: sessionId ? [sessionId] : [],
+      expiresAt: owner.type === 'guest' ? new Date(Date.now() + GUEST_RETENTION_MS).toISOString() : null,
+      deletedByAssistant,
+    };
+
+    await writeEncryptedFile(blobPathFor(entry.id), Buffer.from(buffer), buildAad(entry));
+    state.index.entries[entry.id] = entry;
+    await saveIndex();
+    return sanitizeEntry(entry);
+  },
+
+  async createFolder(owner, { name, parentId = null }) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const resolvedParentId = resolveParentFolder(owner, parentId);
+
+    const folder = {
+      id: crypto.randomUUID(),
+      type: 'folder',
+      name: normalizeName(name, 'New Folder'),
+      ownerType: owner.type,
+      ownerId: owner.id,
+      parentId: resolvedParentId,
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+      trashedAt: null,
+      purgeAt: null,
+      sessionIds: [],
+      expiresAt: owner.type === 'guest' ? new Date(Date.now() + GUEST_RETENTION_MS).toISOString() : null,
+    };
+
+    state.index.entries[folder.id] = folder;
+    await saveIndex();
+    return sanitizeEntry(folder);
+  },
+
+  async createDocument(owner, {
+    name,
+    parentId = null,
+    richText = false,
+    content = '',
+    source = 'upload',
+    sessionId = null,
+  }) {
+    const normalizedName = normalizeName(
+      name,
+      richText ? 'Untitled Document.html' : 'Untitled Document.txt'
+    );
+    return this.storeBuffer(owner, {
+      name: normalizedName,
+      mimeType: richText ? 'text/html' : 'text/plain',
+      buffer: Buffer.from(content || (richText ? '<p></p>' : ''), 'utf8'),
+      parentId,
+      sessionId,
+      source,
+      kind: richText ? 'rich_text' : 'text',
+    });
+  },
+
+  async readBuffer(owner, id) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const entry = getEntry(id);
+    if (!entry || entry.type !== 'file' || !canAccess(entry, owner)) return null;
+    return {
+      entry: sanitizeEntry(entry),
+      buffer: await readEncryptedFile(blobPathFor(id), buildAad(entry)),
+    };
+  },
+
+  async readText(owner, id) {
+    const loaded = await this.readBuffer(owner, id);
+    if (!loaded) return null;
+    return {
+      entry: loaded.entry,
+      text: loaded.buffer.toString('utf8'),
+    };
+  },
+
+  async updateContent(owner, id, { buffer, name = null, mimeType = null, kind = null }) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const entry = getEntry(id);
+    if (!entry || entry.type !== 'file' || !canAccess(entry, owner)) return null;
+    const nextSize = Buffer.byteLength(buffer);
+    const delta = nextSize - (entry.size || 0);
+    if (delta > 0) assertQuotaAvailable(owner, delta);
+
+    if (name) entry.name = normalizeName(name, entry.name);
+    if (mimeType) entry.mimeType = mimeType;
+    if (kind) entry.kind = kind;
+    entry.size = nextSize;
+    entry.updatedAt = nowIso();
+
+    await writeEncryptedFile(blobPathFor(entry.id), Buffer.from(buffer), buildAad(entry));
+    await saveIndex();
+    return sanitizeEntry(entry);
+  },
+
+  async rename(owner, id, name) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const entry = getEntry(id);
+    if (!entry || !canAccess(entry, owner)) return null;
+    entry.name = normalizeName(name, entry.name || 'Untitled');
+    entry.updatedAt = nowIso();
+    await saveIndex();
+    return sanitizeEntry(entry);
+  },
+
+  async move(owner, ids, parentId = null) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const destinationId = parentId ? resolveParentFolder(owner, parentId) : null;
+    if (parentId && !destinationId) throw new Error('Invalid destination folder');
+    const updated = [];
+    for (const id of ids || []) {
+      const entry = getEntry(id);
+      if (!entry || !canAccess(entry, owner)) continue;
+      if (destinationId === entry.id) continue;
+      if (wouldCreateCycle(owner, entry.id, destinationId)) continue;
+      entry.parentId = destinationId;
+      entry.updatedAt = nowIso();
+      updated.push(sanitizeEntry(entry));
+    }
+    if (updated.length) await saveIndex();
+    return updated;
+  },
+
+  async moveToTrash(owner, ids) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const trashed = [];
+    const now = nowIso();
+    const purgeAt = new Date(Date.now() + TRASH_RETENTION_MS).toISOString();
+
+    for (const id of ids || []) {
+      const entry = getEntry(id);
+      if (!entry || !canAccess(entry, owner)) continue;
+      for (const targetId of collectDescendantIds(owner, id)) {
+        const target = getEntry(targetId);
+        if (!target) continue;
+        target.trashedAt = now;
+        target.purgeAt = purgeAt;
+        target.updatedAt = now;
+        trashed.push(sanitizeEntry(target));
+      }
+    }
+    if (trashed.length) await saveIndex();
+    return trashed;
+  },
+
+  async restore(owner, ids) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const restored = [];
+    for (const id of ids || []) {
+      const entry = getEntry(id);
+      if (!entry || !canAccess(entry, owner)) continue;
+      for (const targetId of collectDescendantIds(owner, id)) {
+        const target = getEntry(targetId);
+        if (!target) continue;
+        target.trashedAt = null;
+        target.purgeAt = null;
+        target.updatedAt = nowIso();
+        restored.push(sanitizeEntry(target));
+      }
+    }
+    if (restored.length) await saveIndex();
+    return restored;
+  },
+
+  async deleteForever(owner, ids) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const removedIds = new Set();
+    for (const id of ids || []) {
+      const entry = getEntry(id);
+      if (!entry || !canAccess(entry, owner)) continue;
+      for (const targetId of collectDescendantIds(owner, id)) {
+        removedIds.add(targetId);
+      }
+    }
+    for (const targetId of removedIds) {
+      await purgeEntry(targetId);
+    }
+    if (removedIds.size) await saveIndex();
+    return [...removedIds];
+  },
+
+  async attachToSession(owner, ids, sessionId) {
+    ensureOwner(owner);
+    if (!sessionId) return [];
+    await ensureLoaded();
+    const updated = [];
+    for (const id of ids || []) {
+      const entry = getEntry(id);
+      if (!entry || !canAccess(entry, owner)) continue;
+      entry.sessionIds = [...new Set([...(entry.sessionIds || []), sessionId])];
+      entry.updatedAt = nowIso();
+      updated.push(sanitizeEntry(entry));
+    }
+    if (updated.length) await saveIndex();
+    return updated;
+  },
+
+  async getUsage(owner) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    return computeUsage(owner);
+  },
+};

server/memoryStore.js

@@ -0,0 +1,110 @@
+import crypto from 'crypto';
+import path from 'path';
+import { loadEncryptedJson, saveEncryptedJson } from './cryptoUtils.js';
+
+const DATA_ROOT = '/data/memories';
+const INDEX_FILE = path.join(DATA_ROOT, 'index.json');
+const MAX_MEMORY_LENGTH = 220;
+
+const state = {
+  loaded: false,
+  index: {
+    memories: {},
+  },
+};
+
+function ensureOwner(owner) {
+  if (!owner?.type || !owner?.id) throw new Error('Invalid memory owner');
+  return owner;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function sanitizeText(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim().slice(0, MAX_MEMORY_LENGTH);
+}
+
+async function ensureLoaded() {
+  if (state.loaded) return;
+  const stored = await loadEncryptedJson(INDEX_FILE);
+  state.index = {
+    memories: stored?.memories || {},
+  };
+  state.loaded = true;
+}
+
+async function saveIndex() {
+  await saveEncryptedJson(INDEX_FILE, state.index);
+}
+
+function matchesOwner(memory, owner) {
+  return memory.ownerType === owner.type && memory.ownerId === owner.id;
+}
+
+function sanitize(memory) {
+  return {
+    id: memory.id,
+    content: memory.content,
+    source: memory.source || 'assistant',
+    sessionId: memory.sessionId || null,
+    createdAt: memory.createdAt,
+    updatedAt: memory.updatedAt,
+  };
+}
+
+export const memoryStore = {
+  async list(owner) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    return Object.values(state.index.memories)
+      .filter((memory) => matchesOwner(memory, owner))
+      .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+      .map(sanitize);
+  },
+
+  async create(owner, { content, sessionId = null, source = 'assistant' }) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const normalized = sanitizeText(content);
+    if (!normalized) return null;
+
+    const memory = {
+      id: crypto.randomUUID(),
+      ownerType: owner.type,
+      ownerId: owner.id,
+      content: normalized,
+      sessionId,
+      source,
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+    };
+    state.index.memories[memory.id] = memory;
+    await saveIndex();
+    return sanitize(memory);
+  },
+
+  async update(owner, id, content) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const memory = state.index.memories[id];
+    if (!memory || !matchesOwner(memory, owner)) return null;
+    const normalized = sanitizeText(content);
+    if (!normalized) return null;
+    memory.content = normalized;
+    memory.updatedAt = nowIso();
+    await saveIndex();
+    return sanitize(memory);
+  },
+
+  async delete(owner, id) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const memory = state.index.memories[id];
+    if (!memory || !matchesOwner(memory, owner)) return false;
+    delete state.index.memories[id];
+    await saveIndex();
+    return true;
+  },
+};

server/sessionStore.js

@@ -89,8 +89,24 @@ export const sessionStore = {
     saveTempStore().catch(err => console.error('Failed to save temp store:', err));
     return s;
   },
+  restoreTempSession(t, session) {
+    const d = this.initTemp(t);
+    const restored = JSON.parse(JSON.stringify(session));
+    d.sessions.set(restored.id, restored);
+    d.lastActive = Date.now();
+    saveTempStore().catch(err => console.error('Failed to save temp store:', err));
+    return restored;
+  },
   deleteTempSession(t, id) { tempStore.get(t)?.sessions.delete(id); saveTempStore().catch(err => console.error('Failed to save temp store:', err)); },
   deleteTempAll(t)         { tempStore.get(t)?.sessions.clear(); saveTempStore().catch(err => console.error('Failed to save temp store:', err)); },
+  deleteTempSessionEverywhere(id) {
+    let changed = false;
+    for (const temp of tempStore.values()) {
+      if (temp.sessions.delete(id)) changed = true;
+    }
+    if (changed) saveTempStore().catch(err => console.error('Failed to save temp store:', err));
+    return changed;
+  },
 
   /**
    * Copy temp sessions into the user's account on login.
@@ -146,6 +162,12 @@ export const sessionStore = {
     await this._persist(userClient(accessToken), userId, s).catch(() => {});
     return s;
   },
+  async restoreUserSession(userId, accessToken, session) {
+    const restored = JSON.parse(JSON.stringify(session));
+    this._ensureUser(userId).sessions.set(restored.id, restored);
+    await this._persist(userClient(accessToken), userId, restored).catch(() => {});
+    return restored;
+  },
   async updateUserSession(userId, accessToken, sessionId, patch) {
     const user = userCache.get(userId); if (!user) { console.error("No user for " + userId); return null; }
     const s = user.sessions.get(sessionId); if (!s) { console.error ("No session found for " + sessionId); return null; }
@@ -228,8 +250,8 @@ export const deviceSessionStore = {
       createdAt: new Date().toISOString(), lastSeen: new Date().toISOString(), active: true });
     return token;
   },
-  getForUser(uid)  { return [...devSessions.values()].filter(s => s.userId === uid); },
-  revoke(token)    { const s = devSessions.get(token); if (s) s.active = false; },
+  getForUser(uid)  { return [...devSessions.values()].filter(s => s.userId === uid && s.active); },
+  revoke(token)    { const s = devSessions.get(token); if (s) { s.active = false; return s; } return null; },
   revokeAllExcept(uid, except) {
     for (const [t, s] of devSessions) if (s.userId === uid && t !== except) s.active = false;
   },
@@ -237,4 +259,4 @@ export const deviceSessionStore = {
     const s = devSessions.get(token); if (!s || !s.active) return null;
     s.lastSeen = new Date().toISOString(); return s;
   },
-};
+};

server/systemPromptStore.js

@@ -0,0 +1,174 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { loadEncryptedJson, saveEncryptedJson } from './cryptoUtils.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SYSTEM_PROMPT_FILE = path.resolve(__dirname, '..', 'system prompt.md');
+const DATA_ROOT = '/data/system-prompts';
+const INDEX_FILE = path.join(DATA_ROOT, 'index.json');
+const MAX_PROMPT_LENGTH = 60000;
+
+const FALLBACK_PROMPT = `
+# Response formatting
+
+- Every response must use HTML <span data-color="{COLOR NAME}">...</span> tags to color main points and headings unless the user asks otherwise.
+- Colors must have meaning and stay consistent across the conversation.
+- Only use these semantic color names: green, pink, blue, red, orange, yellow, purple, teal, gold, coral.
+- Never output explicit black or white colors.
+- Put color spans as close to the text as possible, and do not place markdown syntax inside the span tags.
+- Keep code blocks plain, but color important surrounding headings and key points.
+- Do not over-color responses. Use color intentionally and sparingly.
+- Markdown markers such as #, ##, ###, **, and * must stay outside the color spans.
+
+# Core behavior
+
+- You are a helpful, friendly AI assistant.
+- Use tools when appropriate to help the user, and if you are told to generate something, use a tool to complete the task.
+- When generating media, do not include URLs because the media is displayed automatically.
+- You can render SVG images by outputting SVG code in a code block tagged exactly like this:
+
+\`\`\`svg
+<svg>...</svg>
+\`\`\`
+
+- Never use single backslashes.
+- Use markdown for everything other than the color spans.
+- Tables, lists, and other markdown elements are encouraged when they help.
+
+# Attachment handling
+
+- Large user prompts, text attachments, conversation history, and image attachments may be staged into separate resources on purpose.
+- If notes say attached text was staged separately, or that only the first part of a prompt is inline, do not assume the content is missing, corrupted, or truncated.
+- Treat staged content as available context.
+- Use list_prompt_resources to find staged resources.
+- Use read_prompt_chunk to read staged text exactly.
+- Use load_prompt_images to inspect staged images.
+- Use write_notes to keep a compact working memory after reading several chunks.
+- Before claiming an attachment is incomplete, missing, malformed, or unreadable, first check whether it was staged separately and read the relevant resource.
+
+# Memory
+
+- Persistent memories must stay short, concrete, and durable.
+- Only save memories that will still help in future chats.
+- Keep each memory to a brief sentence or phrase.
+- At the start of a chat, always check the memories.
+- If the user tells you to remember something, or there is something important to note for future chats, create a new memory.
+- Memories should be brief.
+- Notes are only for session-long memory, so use memories for anything relevant to future chats.
+
+# Priorities
+
+- Your highest priority is to help the user.
+- Always help with anything ethically right.
+- Make sure your responses are always accurate.
+- If you are not completely sure about something, search the web.
+- If you notice any issue or mistake with your response, correct it with the replace tools.
+- Always answer as correctly as possible, and use search when unsure.
+- Try to minimize the use of * for emphasis. Use it mainly for markdown structure.
+
+# Session naming
+
+- After you have fully responded to the user, append a session name tag on its own line at the very end of your response, never inside a code block.
+- Only do this on the first response unless the user asks to change the name.
+- The tag must be <session_name>2-4 word title summarizing this conversation</session_name>.
+- Example: <session_name>React State Management</session_name>.
+- A conversation must always be named on the first response.
+- This tag is hidden from the user and is used only to name the chat.
+- Do not mention the tag to the user.
+`.trim();
+
+const state = {
+  loaded: false,
+  prompts: {},
+};
+
+let defaultPromptPromise = null;
+
+function normalizePrompt(markdown) {
+  return String(markdown || '')
+    .replace(/\r\n/g, '\n')
+    .trim()
+    .slice(0, MAX_PROMPT_LENGTH);
+}
+
+async function ensureLoaded() {
+  if (state.loaded) return;
+  const stored = await loadEncryptedJson(INDEX_FILE, 'system-prompts');
+  state.prompts = stored?.prompts || {};
+  state.loaded = true;
+}
+
+async function saveIndex() {
+  await saveEncryptedJson(INDEX_FILE, { prompts: state.prompts }, 'system-prompts');
+}
+
+async function loadDefaultPrompt() {
+  if (!defaultPromptPromise) {
+    defaultPromptPromise = fs.readFile(SYSTEM_PROMPT_FILE, 'utf8')
+      .then((content) => normalizePrompt(content) || FALLBACK_PROMPT)
+      .catch(() => FALLBACK_PROMPT);
+  }
+  return defaultPromptPromise;
+}
+
+function sanitizeRecord(record) {
+  if (!record?.markdown) return null;
+  return {
+    markdown: normalizePrompt(record.markdown),
+    updatedAt: record.updatedAt || null,
+  };
+}
+
+export const systemPromptStore = {
+  async getDefaultPrompt() {
+    return loadDefaultPrompt();
+  },
+
+  async getUserPrompt(userId) {
+    if (!userId) return null;
+    await ensureLoaded();
+    return sanitizeRecord(state.prompts[userId]);
+  },
+
+  async getResolvedPrompt(userId) {
+    const custom = await this.getUserPrompt(userId);
+    if (custom?.markdown) return custom.markdown;
+    return this.getDefaultPrompt();
+  },
+
+  async getPersonalization(userId) {
+    const [defaultPrompt, custom] = await Promise.all([
+      this.getDefaultPrompt(),
+      this.getUserPrompt(userId),
+    ]);
+    return {
+      defaultPrompt,
+      customPrompt: custom?.markdown || null,
+      resolvedPrompt: custom?.markdown || defaultPrompt,
+      isCustom: !!custom?.markdown,
+      updatedAt: custom?.updatedAt || null,
+    };
+  },
+
+  async setUserPrompt(userId, markdown) {
+    if (!userId) throw new Error('Missing user id');
+    const normalized = normalizePrompt(markdown);
+    if (!normalized) throw new Error('System prompt cannot be empty');
+    await ensureLoaded();
+    state.prompts[userId] = {
+      markdown: normalized,
+      updatedAt: new Date().toISOString(),
+    };
+    await saveIndex();
+    return this.getPersonalization(userId);
+  },
+
+  async resetUserPrompt(userId) {
+    if (!userId) throw new Error('Missing user id');
+    await ensureLoaded();
+    delete state.prompts[userId];
+    await saveIndex();
+    return this.getPersonalization(userId);
+  },
+};

server/webSearchUsageStore.js

@@ -0,0 +1,91 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+const DATA_DIR = '/data';
+const STORE_FILE = path.join(DATA_DIR, 'web-search-usage.json');
+const APP_TIMEZONE = process.env.APP_TIMEZONE || 'America/New_York';
+
+let state = { days: {} };
+let loaded = false;
+let saveChain = Promise.resolve();
+
+function todayKey() {
+  return new Intl.DateTimeFormat('en-CA', {
+    timeZone: APP_TIMEZONE,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  }).format(new Date());
+}
+
+function pruneDays() {
+  const keepKey = todayKey();
+  state.days = Object.fromEntries(
+    Object.entries(state.days || {}).filter(([key]) => key === keepKey)
+  );
+}
+
+async function ensureLoaded() {
+  if (loaded) return;
+  loaded = true;
+  try {
+    await fs.mkdir(DATA_DIR, { recursive: true });
+    const raw = await fs.readFile(STORE_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object') state = parsed;
+  } catch {}
+  pruneDays();
+}
+
+function saveState() {
+  saveChain = saveChain.then(async () => {
+    pruneDays();
+    await fs.mkdir(DATA_DIR, { recursive: true });
+    await fs.writeFile(STORE_FILE, JSON.stringify(state, null, 2), 'utf8');
+  }).catch((err) => {
+    console.error('Failed to persist web search usage:', err);
+  });
+  return saveChain;
+}
+
+function getCounterRecord(key) {
+  const day = todayKey();
+  if (!state.days[day]) state.days[day] = {};
+  if (!state.days[day][key]) state.days[day][key] = 0;
+  return {
+    day,
+    used: state.days[day][key],
+    set(nextValue) {
+      state.days[day][key] = nextValue;
+    },
+  };
+}
+
+export async function getWebSearchUsage(key, limit = 15) {
+  await ensureLoaded();
+  const record = getCounterRecord(key);
+  return {
+    limit,
+    used: record.used,
+    remaining: Math.max(0, limit - record.used),
+    window: record.day,
+    period: 'daily',
+  };
+}
+
+export async function consumeWebSearchUsage(key, limit = 15) {
+  await ensureLoaded();
+  const record = getCounterRecord(key);
+  if (record.used >= limit) {
+    return {
+      allowed: false,
+      ...(await getWebSearchUsage(key, limit)),
+    };
+  }
+  record.set(record.used + 1);
+  await saveState();
+  return {
+    allowed: true,
+    ...(await getWebSearchUsage(key, limit)),
+  };
+}

server/wsHandler.js

@@ -9,8 +9,14 @@ import {
   getUserProfile, setUsername, getSubscriptionInfo,
   getTierConfig, getUsageInfo,
 } from './auth.js';
-import { streamChat, extractSessionName } from './chatStream.js';
+import { streamChat } from './chatStream.js';
+import { mediaStore } from './mediaStore.js';
+import { memoryStore } from './memoryStore.js';
+import { chatTrashStore } from './chatTrashStore.js';
+import { systemPromptStore } from './systemPromptStore.js';
+import { getWebSearchUsage } from './webSearchUsageStore.js';
 import crypto from 'crypto';
+import path from 'path';
 
 /**
  * Message Structure: Tree-based with versioned tails
@@ -40,9 +46,36 @@ import crypto from 'crypto';
  */
 
 const activeStreams = new Map();
+const VERSION_META_FIELDS = ['toolCalls', 'responseEdits', 'responseSegments', 'error'];
+const CONTINUE_ASSISTANT_PROMPT =
+  'Continue your previous response exactly where it left off. Do not restart, summarize, or repeat the opening. Preserve the same formatting and only add the missing continuation.';
+const FREE_WEB_SEARCH_LIMIT = 15;
 
 initGuestRequestLimiter().catch(err => console.error('Failed to initialize guest request limiter:', err));
 
+function usageOwnerKey(client, clientId = '') {
+  if (client?.userId) return `user:${client.userId}`;
+  return `guest:${clientId || client?.tempId || 'anonymous'}`;
+}
+
+function isFreeSearchPlan(client, usageInfo) {
+  if (!client?.userId) return true;
+  const planKey = usageInfo?.plan_key || usageInfo?.planKey || null;
+  return planKey === 'free';
+}
+
+async function buildUsagePayload(client, clientId = '') {
+  const usageInfo = await getUsageInfo(client?.accessToken, clientId);
+  const webSearchDaily = await getWebSearchUsage(usageOwnerKey(client, clientId), FREE_WEB_SEARCH_LIMIT);
+  return {
+    ...(usageInfo || {}),
+    usage: {
+      ...(usageInfo?.usage || {}),
+      webSearchDaily,
+    },
+  };
+}
+
 export async function handleWsMessage(ws, msg, wsClients) {
   const client = wsClients.get(ws); if (!client) return;
   // Require turnstile verification for most message types
@@ -50,6 +83,23 @@ export async function handleWsMessage(ws, msg, wsClients) {
     return safeSend(ws, { type: 'error', message: 'turnstile:required' });
   }
 
+  const bypassDeviceValidation = new Set([
+    'ping',
+    'turnstile:verify',
+    'auth:login',
+    'auth:guest',
+    'auth:logout',
+  ]);
+  if (client.userId && client.deviceToken && !bypassDeviceValidation.has(msg.type)) {
+    const activeDeviceSession = deviceSessionStore.validate(client.deviceToken);
+    if (!activeDeviceSession) {
+      const priorUserId = client.userId;
+      Object.assign(client, { userId: null, authenticated: false, accessToken: null, deviceToken: null });
+      sessionStore.markOffline(priorUserId, ws);
+      return safeSend(ws, { type: 'auth:forcedLogout', reason: 'Session revoked by another device' });
+    }
+  }
+
   const h = handlers[msg.type];
   if (h) return h(ws, msg, client, wsClients);
   safeSend(ws, { type: 'error', message: `Unknown: ${msg.type}` });
@@ -77,13 +127,30 @@ const handlers = {
   },
 
   'auth:login': async (ws, msg, client, wsClients) => {
-    const { accessToken, tempId: clientTempId } = msg;
+    const { accessToken, tempId: clientTempId, deviceToken: requestedDeviceToken } = msg;
     if (!accessToken) return safeSend(ws, { type: 'auth:error', message: 'Missing token' });
     const user = await verifySupabaseToken(accessToken);
     if (!user) return safeSend(ws, { type: 'auth:error', message: 'Invalid token' });
 
+    let nextDeviceToken = null;
+    let reusedDeviceSession = false;
+    if (requestedDeviceToken) {
+      const existingDevice = deviceSessionStore.validate(requestedDeviceToken);
+      if (existingDevice?.userId === user.id) {
+        existingDevice.ip = client.ip;
+        existingDevice.userAgent = client.userAgent;
+        nextDeviceToken = existingDevice.token;
+        reusedDeviceSession = true;
+      }
+    }
+    if (!nextDeviceToken) {
+      nextDeviceToken = deviceSessionStore.create(user.id, client.ip, client.userAgent);
+    }
+    if (client.deviceToken && client.deviceToken !== nextDeviceToken) {
+      deviceSessionStore.revoke(client.deviceToken);
+    }
     client.userId = user.id; client.accessToken = accessToken; client.authenticated = true;
-    client.deviceToken = deviceSessionStore.create(user.id, client.ip, client.userAgent);
+    client.deviceToken = nextDeviceToken;
     sessionStore.markOnline(user.id, ws);
 
     if (clientTempId) client.tempId = clientTempId;
@@ -101,13 +168,17 @@ const handlers = {
       deviceToken: client.deviceToken, sessions: sessions.map(ser), settings, profile, subscription };
     safeSend(ws, authOkMsg);
 
-    bcast(wsClients, user.id, { type: 'auth:newLogin', message: 'New login on your account.',
-      ip: client.ip, userAgent: client.userAgent, timestamp: new Date().toISOString() }, ws);
+    if (!reusedDeviceSession) {
+      bcast(wsClients, user.id, { type: 'auth:newLogin', message: 'New login on your account.',
+        ip: client.ip, userAgent: client.userAgent, timestamp: new Date().toISOString() }, ws);
+    }
   },
 
   'auth:logout': (ws, msg, client) => {
+    const priorUserId = client.userId;
     if (client.deviceToken) deviceSessionStore.revoke(client.deviceToken);
     Object.assign(client, { userId: null, authenticated: false, accessToken: null, deviceToken: null });
+    if (priorUserId) sessionStore.markOffline(priorUserId, ws);
     safeSend(ws, { type: 'auth:loggedOut' });
   },
 
@@ -134,15 +205,36 @@ const handlers = {
   },
 
   'sessions:delete': async (ws, msg, client) => {
-    if (client.userId) await sessionStore.deleteUserSession(client.userId, client.accessToken, msg.sessionId);
-    else sessionStore.deleteTempSession(client.tempId, msg.sessionId);
+    const owner = getClientOwner(client);
+    const session = client.userId
+      ? sessionStore.getUserSession(client.userId, msg.sessionId)
+      : sessionStore.getTempSession(client.tempId, msg.sessionId);
+    if (!session) return safeSend(ws, { type: 'error', message: 'Session not found' });
+
+    await chatTrashStore.add(owner, JSON.parse(JSON.stringify(session)));
+    if (client.userId) {
+      await sessionStore.deleteUserSession(client.userId, client.accessToken, msg.sessionId);
+      sessionStore.deleteTempSessionEverywhere(msg.sessionId);
+    } else {
+      sessionStore.deleteTempSession(client.tempId, msg.sessionId);
+    }
     safeSend(ws, { type: 'sessions:deleted', sessionId: msg.sessionId });
+    safeSend(ws, { type: 'trash:chats:changed' });
   },
 
   'sessions:deleteAll': async (ws, msg, client) => {
+    const owner = getClientOwner(client);
+    const sessions = client.userId
+      ? sessionStore.getUserSessions(client.userId)
+      : sessionStore.getTempSessions(client.tempId);
+    for (const session of sessions) {
+      await chatTrashStore.add(owner, JSON.parse(JSON.stringify(session)));
+      if (client.userId) sessionStore.deleteTempSessionEverywhere(session.id);
+    }
     if (client.userId) await sessionStore.deleteAllUserSessions(client.userId, client.accessToken);
     else sessionStore.deleteTempAll(client.tempId);
     safeSend(ws, { type: 'sessions:deletedAll' });
+    safeSend(ws, { type: 'trash:chats:changed' });
   },
 
   'sessions:rename': async (ws, msg, client) => {
@@ -175,8 +267,34 @@ const handlers = {
     safeSend(ws, { type: 'sessions:imported', session: ser(s) });
   },
 
+  'trash:chats:list': async (ws, msg, client) => {
+    const owner = getClientOwner(client);
+    const items = await chatTrashStore.list(owner);
+    safeSend(ws, { type: 'trash:chats:list', items });
+  },
+
+  'trash:chats:restore': async (ws, msg, client) => {
+    const owner = getClientOwner(client);
+    const restored = await chatTrashStore.restore(owner, msg.ids || []);
+    const sessions = [];
+    for (const snapshot of restored) {
+      const restoredSession = await restoreDeletedSession(client, snapshot);
+      if (restoredSession) sessions.push(ser(restoredSession));
+    }
+    safeSend(ws, { type: 'trash:chats:restored', sessions });
+    safeSend(ws, { type: 'trash:chats:changed' });
+  },
+
+  'trash:chats:deleteForever': async (ws, msg, client) => {
+    const owner = getClientOwner(client);
+    const removedIds = await chatTrashStore.deleteForever(owner, msg.ids || []);
+    safeSend(ws, { type: 'trash:chats:deletedForever', ids: removedIds });
+    safeSend(ws, { type: 'trash:chats:changed' });
+  },
+
   'chat:send': async (ws, msg, client) => {
     const { sessionId, content, tools } = msg;
+    const owner = getClientOwner(client);
     if (!client.userId) {
       const allowed = await consumeGuestRequest(client.ip || 'unknown');
       if (!allowed) return safeSend(ws, { type: 'guest:rateLimit', message: 'Guest request limit exceeded' });
@@ -200,27 +318,48 @@ const handlers = {
     const rootMessage = session.history?.[0];
     const flatHistory = rootMessage ? extractFlatHistory(rootMessage) : [];
 
+    if (Array.isArray(msg.linkedMediaIds) && msg.linkedMediaIds.length) {
+      await mediaStore.attachToSession(owner, msg.linkedMediaIds, sessionId).catch((err) => {
+        console.error('Failed to link uploaded media to session:', err);
+      });
+    }
+
+    const usagePayload = await buildUsagePayload(client, msg.clientId || '');
+    const webSearchLimit = isFreeSearchPlan(client, usagePayload)
+      ? { key: usageOwnerKey(client, msg.clientId || ''), limit: FREE_WEB_SEARCH_LIMIT }
+      : null;
+
     await streamChat({
       sessionId,
       model: session.model,
-      history: flatHistory, 
-      userMessage: content, 
+      history: flatHistory,
+      userMessage: content,
       tools: tools || {},
-      accessToken: client.accessToken, 
-      clientId: msg.clientId, 
+      accessToken: client.accessToken,
+      clientId: msg.clientId,
+      webSearchLimit,
+      owner,
+      sessionName: session.name,
       abortSignal: abort.signal,
       onToken(t) { fullText += t; safeSend(ws, { type: 'chat:token', token: t, sessionId }); },
       onToolCall(call) {
         safeSend(ws, { type: 'chat:toolCall', call, sessionId });
         if (call.state === 'resolved' || call.state === 'canceled') toolCallsCollected.push(call);
       },
-      onNewAsset(asset) { safeSend(ws, { type: 'chat:asset', asset, sessionId }); assetsCollected.push(asset); },
-      async onDone(text, toolCalls, aborted, sessionNameFromTag) {
+      onNewAsset(asset) {
+        safeSend(ws, { type: 'chat:asset', asset, sessionId });
+        assetsCollected.push(asset);
+        safeSend(ws, { type: 'media:changed' });
+      },
+      onDraftEdit(edit, draftText) {
+        safeSend(ws, { type: 'chat:draftEdited', edit, text: draftText, sessionId });
+      },
+      async onDone(text, toolCalls, aborted, sessionNameFromTag, responseEdits = [], responseSegments = []) {
         activeStreams.delete(ws);
         const finalText = text || fullText;
-        
+
         // Only create user entry if content was actually provided
-        const hasContent = content !== undefined && content !== null && content !== '' && 
+        const hasContent = content !== undefined && content !== null && content !== '' &&
           !(Array.isArray(content) && content.length === 0);
         const userEntry = hasContent
           ? buildEntry('user', content)
@@ -231,27 +370,48 @@ const handlers = {
           const resolved = resolvedMap.get(c.id) || {};
           return { ...c, state: resolved.state || 'resolved', result: resolved.result };
         });
-        const asstEntry = buildEntry('assistant', finalText, mergedCalls);
+        const asstEntry = buildEntry('assistant', finalText, mergedCalls, {
+          responseEdits,
+          responseSegments,
+        });
+
+        const mediaEntries = assetsCollected.map((asset) =>
+          buildMediaEntry(asset.role, {
+            assetId: asset.id,
+            mimeType: asset.mimeType,
+            name: asset.name,
+          })
+        );
+
+        const generatedFiles = extractAssistantGeneratedFiles(finalText);
+        for (const file of generatedFiles) {
+          await mediaStore.storeBuffer(owner, {
+            name: file.name,
+            mimeType: file.mimeType,
+            buffer: file.buffer,
+            sessionId,
+            source: 'assistant_generated',
+            kind: file.kind,
+          }).catch((err) => console.error('Failed to store generated text asset:', err));
+        }
+        if (generatedFiles.length) safeSend(ws, { type: 'media:changed' });
+
+        // Rebuild tree structure with new messages appended to the active branch leaf.
+        let newRootMessage = rootMessage ? cloneAndRepairTree(rootMessage) : null;
 
-        // Rebuild tree structure with new messages appended
-        let newRootMessage = rootMessage ? validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage))) : null;
-        
         if (!newRootMessage) {
           // First message in session - must have user entry
           if (!userEntry) return safeSend(ws, { type: 'error', message: 'No content for first message' });
           newRootMessage = userEntry;
-          const asstWrap = { ...asstEntry };
-          newRootMessage.versions[0].tail = [asstWrap];
+          newRootMessage.versions[0].tail = [{ ...asstEntry }, ...mediaEntries];
+        } else if (userEntry) {
+          appendConversationTurn(newRootMessage, userEntry, asstEntry, mediaEntries);
         } else {
-          // Append to current tail
-          const currentVerIdx = newRootMessage.currentVersionIdx ?? 0;
-          let currentTail = newRootMessage.versions[currentVerIdx].tail || [];
-          currentTail = JSON.parse(JSON.stringify(currentTail));
-          if (userEntry) {
-            currentTail.push(userEntry);
-          }
-          currentTail.push(asstEntry);
-          newRootMessage.versions[currentVerIdx].tail = currentTail;
+          const appendedEntries = [
+            asstEntry,
+            ...mediaEntries,
+          ];
+          appendEntriesToActiveLeaf(newRootMessage, appendedEntries);
         }
 
         const newHistory = [newRootMessage];
@@ -266,13 +426,13 @@ const handlers = {
         if (client.userId)
           await sessionStore.updateUserSession(client.userId, client.accessToken, sessionId, { history: newHistory, name: newName });
         else sessionStore.updateTempSession(client.tempId, sessionId, { history: newHistory, name: newName });
-        
+
         safeSend(ws, { type: aborted ? 'chat:aborted' : 'chat:done', sessionId, name: newName, history: extractFlatHistory(newRootMessage) });
       },
-      onError(err) { 
+      onError(err) {
         activeStreams.delete(ws);
         console.error('streamChat error:', err);
-        safeSend(ws, { type: 'chat:error', error: String(err), sessionId }); 
+        safeSend(ws, { type: 'chat:error', error: String(err), sessionId });
       },
     });
   },
@@ -297,8 +457,18 @@ const handlers = {
     }
     
     // Find the target message in the tree and add new version
-    const newRoot = validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage)));
+    const newRoot = cloneAndRepairTree(rootMessage);
+    const context = findMessageContext(newRoot, targetMsg.id);
+    if (!context?.message) return safeSend(ws, { type: 'error', message: 'Message not found in tree' });
+
     const found = findAndUpdateMessage(newRoot, targetMsg.id, (msgInTree) => {
+      if (msgInTree.role === 'user' && Array.isArray(context.parentTail) && context.index >= 0) {
+        const trailing = context.parentTail.splice(context.index + 1);
+        if (trailing.length) {
+          const currentVersion = getActiveVersion(msgInTree);
+          currentVersion.tail = [...(currentVersion.tail || []), ...trailing];
+        }
+      }
       // Add new version with EMPTY tail (no responses yet for this edited version)
       msgInTree.versions.push({
         content: newContent,
@@ -345,7 +515,7 @@ const handlers = {
     if (!targetMsg || !targetMsg.versions || versionIdx >= targetMsg.versions.length) return;
     
     // Find and update the message in tree, switching to specified version
-    const newRoot = validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage)));
+    const newRoot = cloneAndRepairTree(rootMessage);
     const found = findAndUpdateMessage(newRoot, targetMsg.id, (msgInTree) => {
       msgInTree.currentVersionIdx = versionIdx;
       msgInTree.content = msgInTree.versions[versionIdx].content;
@@ -365,6 +535,162 @@ const handlers = {
     safeSend(ws, { type: 'chat:versionSelected', sessionId, messageId: targetMsg.id, messageIndex, history: extractFlatHistory(newRoot) });
   },
 
+  'chat:assistantAction': async (ws, msg, client) => {
+    const { sessionId, messageIndex } = msg;
+    const action = msg.action === 'continue' ? 'continue' : 'regenerate';
+    const session = client.userId
+      ? sessionStore.getUserSession(client.userId, sessionId)
+      : sessionStore.getTempSession(client.tempId, sessionId);
+    if (!session) return safeSend(ws, { type: 'error', message: 'Session not found' });
+
+    const rootMessage = session.history?.[0];
+    if (!rootMessage) return safeSend(ws, { type: 'error', message: 'No history' });
+
+    const flatHistory = extractFlatHistory(rootMessage);
+    const targetMsg = flatHistory[messageIndex];
+    if (!targetMsg || targetMsg.role !== 'assistant') {
+      return safeSend(ws, { type: 'error', message: 'Assistant message not found' });
+    }
+
+    if (activeStreams.has(ws)) activeStreams.get(ws).abort();
+    const abort = new AbortController();
+    activeStreams.set(ws, abort);
+
+    const owner = getClientOwner(client);
+    const historyBeforeTarget = flatHistory.slice(0, messageIndex);
+    const baseAssistantText = stripSessionTagText(targetMsg.content || '');
+    const actionHistory = action === 'continue'
+      ? [...historyBeforeTarget, { role: 'assistant', content: baseAssistantText }]
+      : historyBeforeTarget;
+    const actionUserMessage = action === 'continue' ? CONTINUE_ASSISTANT_PROMPT : null;
+
+    safeSend(ws, {
+      type: 'chat:start',
+      sessionId,
+      streamKind: 'assistantAction',
+      action,
+      messageIndex,
+      prefillText: action === 'continue' ? baseAssistantText : '',
+    });
+
+    let fullText = '';
+    const assetsCollected = [];
+    const toolCallsCollected = [];
+    const usagePayload = await buildUsagePayload(client, msg.clientId || '');
+    const webSearchLimit = isFreeSearchPlan(client, usagePayload)
+      ? { key: usageOwnerKey(client, msg.clientId || ''), limit: FREE_WEB_SEARCH_LIMIT }
+      : null;
+
+    await streamChat({
+      sessionId,
+      model: session.model,
+      history: actionHistory,
+      userMessage: actionUserMessage,
+      tools: msg.tools || {},
+      accessToken: client.accessToken,
+      clientId: msg.clientId,
+      webSearchLimit,
+      owner,
+      sessionName: session.name,
+      abortSignal: abort.signal,
+      onToken(t) {
+        fullText += t;
+        safeSend(ws, { type: 'chat:token', token: t, sessionId });
+      },
+      onToolCall(call) {
+        safeSend(ws, { type: 'chat:toolCall', call, sessionId });
+        if (call.state === 'resolved' || call.state === 'canceled') toolCallsCollected.push(call);
+      },
+      onNewAsset(asset) {
+        safeSend(ws, { type: 'chat:asset', asset, sessionId });
+        assetsCollected.push(asset);
+        safeSend(ws, { type: 'media:changed' });
+      },
+      onDraftEdit(edit, draftText) {
+        safeSend(ws, { type: 'chat:draftEdited', edit, text: draftText, sessionId });
+      },
+      async onDone(text, toolCalls, aborted, sessionNameFromTag, responseEdits = [], responseSegments = []) {
+        activeStreams.delete(ws);
+        if (aborted) {
+          return safeSend(ws, { type: 'chat:aborted', sessionId });
+        }
+
+        const rawAssistantText = text || fullText;
+        const resolvedMap = new Map(toolCallsCollected.map((call) => [call.id, call]));
+        const mergedCalls = (toolCalls || []).map((call) => {
+          const resolved = resolvedMap.get(call.id) || {};
+          return { ...call, state: resolved.state || 'resolved', result: resolved.result };
+        });
+
+        let finalText = rawAssistantText;
+        let finalSegments = responseSegments;
+
+        if (action === 'continue') {
+          const { continuationText, overlapLength } = stripContinuationOverlap(baseAssistantText, rawAssistantText);
+          finalText = baseAssistantText + continuationText;
+          finalSegments = [
+            ...(baseAssistantText ? [{ type: 'text', text: baseAssistantText }] : []),
+            ...trimLeadingTextFromSegments(responseSegments, overlapLength),
+          ];
+        }
+
+        const mediaEntries = assetsCollected.map((asset) =>
+          buildMediaEntry(asset.role, {
+            assetId: asset.id,
+            mimeType: asset.mimeType,
+            name: asset.name,
+          })
+        );
+
+        const generatedFiles = extractAssistantGeneratedFiles(finalText);
+        for (const file of generatedFiles) {
+          await mediaStore.storeBuffer(owner, {
+            name: file.name,
+            mimeType: file.mimeType,
+            buffer: file.buffer,
+            sessionId,
+            source: 'assistant_generated',
+            kind: file.kind,
+          }).catch((err) => console.error('Failed to store generated text asset:', err));
+        }
+        if (generatedFiles.length) safeSend(ws, { type: 'media:changed' });
+
+        const newRoot = cloneAndRepairTree(rootMessage);
+        const found = findAndUpdateMessage(newRoot, targetMsg.id, (msgInTree) => {
+          const nextVersion = buildVersionRecord(finalText, {
+            tail: mediaEntries,
+            toolCalls: mergedCalls,
+            responseEdits,
+            responseSegments: finalSegments,
+          });
+          applyVersionToMessage(msgInTree, nextVersion);
+        });
+        if (!found) {
+          return safeSend(ws, { type: 'error', message: 'Assistant branch could not be updated' });
+        }
+
+        let newName = session.name;
+        if (sessionNameFromTag) {
+          newName = sessionNameFromTag;
+        }
+
+        const newHistory = [newRoot];
+        if (client.userId) {
+          await sessionStore.updateUserSession(client.userId, client.accessToken, sessionId, { history: newHistory, name: newName });
+        } else {
+          sessionStore.updateTempSession(client.tempId, sessionId, { history: newHistory, name: newName });
+        }
+
+        safeSend(ws, { type: 'chat:done', sessionId, name: newName, history: extractFlatHistory(newRoot) });
+      },
+      onError(err) {
+        activeStreams.delete(ws);
+        console.error('assistant action streamChat error:', err);
+        safeSend(ws, { type: 'chat:error', error: String(err), sessionId });
+      },
+    });
+  },
+
   'settings:get': async (ws, msg, client) => {
     const s = client.userId
       ? await getUserSettings(client.userId, client.accessToken)
@@ -378,6 +704,72 @@ const handlers = {
     bcast(wsClients, client.userId, { type: 'settings:updated', settings: msg.settings }, ws);
   },
 
+  'personalization:get': async (ws, msg, client) => {
+    const defaultPrompt = await systemPromptStore.getDefaultPrompt();
+    const personalization = client.userId
+      ? await systemPromptStore.getPersonalization(client.userId)
+      : {
+          defaultPrompt,
+          customPrompt: null,
+          resolvedPrompt: defaultPrompt,
+          isCustom: false,
+          updatedAt: null,
+          canEdit: false,
+        };
+    safeSend(ws, { type: 'personalization:data', personalization });
+  },
+  'personalization:saveSystemPrompt': async (ws, msg, client, wsClients) => {
+    if (!client.userId) return safeSend(ws, { type: 'personalization:error', message: 'Sign in to customize your system prompt' });
+    try {
+      const personalization = await systemPromptStore.setUserPrompt(client.userId, msg.markdown);
+      safeSend(ws, { type: 'personalization:updated', personalization });
+      bcast(wsClients, client.userId, { type: 'personalization:updated', personalization }, ws);
+    } catch (err) {
+      safeSend(ws, { type: 'personalization:error', message: err.message || 'Unable to save system prompt' });
+    }
+  },
+  'personalization:resetSystemPrompt': async (ws, msg, client, wsClients) => {
+    if (!client.userId) return safeSend(ws, { type: 'personalization:error', message: 'Sign in to customize your system prompt' });
+    try {
+      const personalization = await systemPromptStore.resetUserPrompt(client.userId);
+      safeSend(ws, { type: 'personalization:updated', personalization });
+      bcast(wsClients, client.userId, { type: 'personalization:updated', personalization }, ws);
+    } catch (err) {
+      safeSend(ws, { type: 'personalization:error', message: err.message || 'Unable to reset system prompt' });
+    }
+  },
+
+  'memories:list': async (ws, msg, client) => {
+    const owner = getClientOwner(client);
+    const items = await memoryStore.list(owner);
+    safeSend(ws, { type: 'memories:list', items });
+  },
+
+  'memories:create': async (ws, msg, client, wsClients) => {
+    const owner = getClientOwner(client);
+    const memory = await memoryStore.create(owner, {
+      content: msg.content,
+      sessionId: msg.sessionId || null,
+      source: msg.source || 'manual',
+    });
+    safeSend(ws, { type: 'memories:created', memory });
+    if (client.userId) bcast(wsClients, client.userId, { type: 'memories:changed' }, ws);
+  },
+
+  'memories:update': async (ws, msg, client, wsClients) => {
+    const owner = getClientOwner(client);
+    const memory = await memoryStore.update(owner, msg.id, msg.content);
+    safeSend(ws, { type: 'memories:updated', memory });
+    if (client.userId) bcast(wsClients, client.userId, { type: 'memories:changed' }, ws);
+  },
+
+  'memories:delete': async (ws, msg, client, wsClients) => {
+    const owner = getClientOwner(client);
+    const ok = await memoryStore.delete(owner, msg.id);
+    safeSend(ws, { type: 'memories:deleted', id: ok ? msg.id : null });
+    if (client.userId) bcast(wsClients, client.userId, { type: 'memories:changed' }, ws);
+  },
+
   'account:getProfile':      async (ws, msg, c) => { if (!c.userId) return; safeSend(ws, { type: 'account:profile', profile: await getUserProfile(c.userId, c.accessToken) }); },
   'account:setUsername':     async (ws, msg, c) => { if (!c.userId) return; safeSend(ws, { type: 'account:usernameResult', ...await setUsername(c.userId, c.accessToken, msg.username) }); },
   'account:getSubscription': async (ws, msg, c) => { 
@@ -385,26 +777,80 @@ const handlers = {
     const subInfo = await getSubscriptionInfo(c.accessToken);
     safeSend(ws, { type: 'account:subscription', info: subInfo });
   },
-  'account:getUsage':        async (ws, msg, c) => { safeSend(ws, { type: 'account:usage', usage: await getUsageInfo(c.accessToken) }); },
+  'account:getUsage':        async (ws, msg, c) => { safeSend(ws, { type: 'account:usage', usage: await buildUsagePayload(c, msg.clientId || '') }); },
   'account:getTierConfig':   async (ws)          => { safeSend(ws, { type: 'account:tierConfig', config: await getTierConfig() }); },
   'account:getSessions':     (ws, msg, c)         => { if (!c.userId) return; safeSend(ws, { type: 'account:deviceSessions', sessions: deviceSessionStore.getForUser(c.userId), currentToken: c.deviceToken }); },
-  'account:revokeSession':   (ws, msg, c)         => { if (!c.userId) return; deviceSessionStore.revoke(msg.token); safeSend(ws, { type: 'account:sessionRevoked', token: msg.token }); },
+  'account:revokeSession':   (ws, msg, c, wsClients) => {
+    if (!c.userId || !msg.token) return;
+    const revoked = deviceSessionStore.revoke(msg.token);
+    if (revoked) {
+      const activeSessions = deviceSessionStore.getForUser(c.userId);
+      for (const [ows, oc] of wsClients) {
+        if (oc.userId !== c.userId) continue;
+        if (oc.deviceToken === msg.token) {
+          safeSend(ows, { type: 'auth:forcedLogout', reason: 'Session revoked by another device' });
+          sessionStore.markOffline(oc.userId, ows);
+          Object.assign(oc, { userId: null, authenticated: false, accessToken: null, deviceToken: null });
+          continue;
+        }
+        safeSend(ows, {
+          type: 'account:deviceSessions',
+          sessions: activeSessions,
+          currentToken: oc.deviceToken,
+        });
+      }
+    }
+    safeSend(ws, { type: 'account:sessionRevoked', token: msg.token });
+  },
   'account:revokeAllOthers': (ws, msg, c, wsClients) => {
     if (!c.userId) return;
     deviceSessionStore.revokeAllExcept(c.userId, c.deviceToken);
-    for (const [ows, oc] of wsClients)
-      if (oc.userId === c.userId && ows !== ws) safeSend(ows, { type: 'auth:forcedLogout', reason: 'Session revoked by another device' });
+    const activeSessions = deviceSessionStore.getForUser(c.userId);
+    for (const [ows, oc] of wsClients) {
+      if (oc.userId !== c.userId) continue;
+      if (oc.deviceToken && oc.deviceToken !== c.deviceToken) {
+        safeSend(ows, { type: 'auth:forcedLogout', reason: 'Session revoked by another device' });
+        sessionStore.markOffline(oc.userId, ows);
+        Object.assign(oc, { userId: null, authenticated: false, accessToken: null, deviceToken: null });
+        continue;
+      }
+      safeSend(ows, {
+        type: 'account:deviceSessions',
+        sessions: activeSessions,
+        currentToken: oc.deviceToken,
+      });
+    }
     safeSend(ws, { type: 'account:allOthersRevoked' });
   },
 };
 
 function ser(s) { return { id: s.id, name: s.name, created: s.created, history: s.history || [], model: s.model }; }
 
+function getClientOwner(client) {
+  return client.userId
+    ? { type: 'user', id: client.userId }
+    : { type: 'guest', id: client.tempId };
+}
+
+async function restoreDeletedSession(client, snapshot) {
+  if (!snapshot) return null;
+  const restored = JSON.parse(JSON.stringify(snapshot));
+  const existing = client.userId
+    ? sessionStore.getUserSession(client.userId, restored.id)
+    : sessionStore.getTempSession(client.tempId, restored.id);
+  if (existing) restored.id = crypto.randomUUID();
+  restored.created = restored.created || Date.now();
+  if (client.userId) {
+    return sessionStore.restoreUserSession(client.userId, client.accessToken, restored);
+  }
+  return sessionStore.restoreTempSession(client.tempId, restored);
+}
+
 function generateMessageId() {
   return `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 }
 
-function buildEntry(role, content, toolCalls = []) {
+function buildEntry(role, content, toolCalls = [], extraFields = {}) {
   const normalizedCalls = toolCalls.map(c => ({
     id:     c.id,
     name:   c.name || c.function?.name,
@@ -413,17 +859,151 @@ function buildEntry(role, content, toolCalls = []) {
     result: c.result,
   }));
   const validContent = (content === undefined || content === null) ? '' : content;
+  const versionMeta = {};
+  const topLevelExtraFields = { ...extraFields };
+  VERSION_META_FIELDS.forEach((key) => {
+    if (key in topLevelExtraFields) {
+      versionMeta[key] = topLevelExtraFields[key];
+      delete topLevelExtraFields[key];
+    }
+  });
   return { 
     id: generateMessageId(),
     role, 
     content: validContent, 
     timestamp: Date.now(),
-    versions: [{ content: validContent, tail: [], timestamp: Date.now() }], 
+    versions: [{
+      content: validContent,
+      tail: [],
+      timestamp: Date.now(),
+      ...(normalizedCalls.length ? { toolCalls: normalizedCalls } : {}),
+      ...versionMeta,
+    }],
+    currentVersionIdx: 0,
+    ...(normalizedCalls.length ? { toolCalls: normalizedCalls } : {}),
+    ...versionMeta,
+    ...topLevelExtraFields,
+  };
+}
+
+function buildMediaEntry(role, content) {
+  return {
+    id: generateMessageId(),
+    role,
+    content,
+    timestamp: Date.now(),
+    versions: [{ content, tail: [], timestamp: Date.now() }],
     currentVersionIdx: 0,
-    ...(normalizedCalls.length ? { toolCalls: normalizedCalls } : {}) 
   };
 }
 
+function buildVersionRecord(content, extraFields = {}) {
+  const validContent = content === undefined || content === null ? '' : content;
+  const version = {
+    content: validContent,
+    tail: Array.isArray(extraFields.tail) ? extraFields.tail : [],
+    timestamp: Date.now(),
+  };
+  VERSION_META_FIELDS.forEach((key) => {
+    if (extraFields[key] !== undefined && extraFields[key] !== null) {
+      version[key] = extraFields[key];
+    }
+  });
+  return version;
+}
+
+function applyVersionToMessage(message, versionRecord) {
+  if (!message?.versions || !Array.isArray(message.versions)) {
+    message.versions = [];
+  }
+  message.versions.push(versionRecord);
+  message.currentVersionIdx = message.versions.length - 1;
+  syncMessageFromActiveVersion(message);
+  return message;
+}
+
+function stripSessionTagText(content) {
+  return typeof content === 'string'
+    ? content.replace(/<session_name>[\s\S]*?<\/session_name>/gi, '').trim()
+    : content;
+}
+
+function stripContinuationOverlap(baseText = '', generatedText = '') {
+  const base = String(baseText || '');
+  const generated = String(generatedText || '');
+  if (!base) return { continuationText: generated, overlapLength: 0 };
+  if (!generated) return { continuationText: '', overlapLength: 0 };
+  if (generated.startsWith(base)) {
+    return { continuationText: generated.slice(base.length), overlapLength: base.length };
+  }
+
+  const maxWindow = Math.min(base.length, generated.length, 400);
+  for (let size = maxWindow; size > 0; size--) {
+    if (base.slice(-size) === generated.slice(0, size)) {
+      return { continuationText: generated.slice(size), overlapLength: size };
+    }
+  }
+
+  return { continuationText: generated, overlapLength: 0 };
+}
+
+function trimLeadingTextFromSegments(segments = [], overlapLength = 0) {
+  let remaining = Math.max(0, overlapLength);
+  const trimmedSegments = [];
+
+  for (const segment of segments || []) {
+    if (!segment || segment.type !== 'text' || remaining <= 0) {
+      trimmedSegments.push(segment);
+      continue;
+    }
+
+    const text = String(segment.text || '');
+    if (remaining >= text.length) {
+      remaining -= text.length;
+      continue;
+    }
+
+    trimmedSegments.push({
+      ...segment,
+      text: text.slice(remaining),
+    });
+    remaining = 0;
+  }
+
+  return trimmedSegments.filter((segment) => segment && (segment.type !== 'text' || segment.text));
+}
+
+function extractAssistantGeneratedFiles(text) {
+  if (!text || typeof text !== 'string') return [];
+  const files = [];
+  const detailsRe = /<details><summary>([^<]+?)<\/summary>\s*```(?:\w*)\n([\s\S]*?)\n```\s*<\/details>/g;
+  const svgRe = /```svg\n([\s\S]*?)\n```/g;
+  let match;
+
+  while ((match = detailsRe.exec(text)) !== null) {
+    const name = String(match[1] || '').trim();
+    const ext = path.extname(name).toLowerCase();
+    files.push({
+      name: name || 'generated-file.txt',
+      mimeType: ext === '.html' || ext === '.htm' ? 'text/html' : 'text/plain',
+      kind: ext === '.html' || ext === '.htm' ? 'rich_text' : 'text',
+      buffer: Buffer.from(match[2], 'utf8'),
+    });
+  }
+
+  let svgIndex = 1;
+  while ((match = svgRe.exec(text)) !== null) {
+    files.push({
+      name: `generated-image-${svgIndex++}.svg`,
+      mimeType: 'image/svg+xml',
+      kind: 'image',
+      buffer: Buffer.from(match[1], 'utf8'),
+    });
+  }
+
+  return files;
+}
+
 /**
  * Validate and repair tree structure after cloning/modification
  * Ensures all messages and versions have valid content property
@@ -454,6 +1034,84 @@ function validateAndRepairTree(rootMessage) {
   return rootMessage;
 }
 
+function cloneAndRepairTree(rootMessage) {
+  return validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage)));
+}
+
+function getActiveVersion(message) {
+  if (!message) return null;
+  const versions = Array.isArray(message.versions) ? message.versions : [];
+  if (!versions.length) {
+    message.versions = [{ content: message.content ?? '', tail: [], timestamp: Date.now() }];
+    message.currentVersionIdx = 0;
+    return message.versions[0];
+  }
+  const currentVersionIdx = Number.isInteger(message.currentVersionIdx)
+    ? Math.max(0, Math.min(message.currentVersionIdx, versions.length - 1))
+    : 0;
+  message.currentVersionIdx = currentVersionIdx;
+  if (!Array.isArray(message.versions[currentVersionIdx].tail)) {
+    message.versions[currentVersionIdx].tail = [];
+  }
+  if (message.versions[currentVersionIdx].content === undefined || message.versions[currentVersionIdx].content === null) {
+    message.versions[currentVersionIdx].content = message.content ?? '';
+  }
+  return message.versions[currentVersionIdx];
+}
+
+function cloneVersionMetaValue(value) {
+  if (value === undefined) return undefined;
+  return JSON.parse(JSON.stringify(value));
+}
+
+function syncMessageFromActiveVersion(message) {
+  if (!message) return message;
+  const currentVersion = getActiveVersion(message);
+  if (!currentVersion) return message;
+  message.content = currentVersion.content ?? message.content ?? '';
+  VERSION_META_FIELDS.forEach((key) => {
+    if (key in currentVersion) {
+      message[key] = cloneVersionMetaValue(currentVersion[key]);
+    } else {
+      delete message[key];
+    }
+  });
+  return message;
+}
+
+function getActiveLeafMessage(rootMessage) {
+  let current = rootMessage;
+  while (current) {
+    const currentVersion = getActiveVersion(current);
+    const tail = Array.isArray(currentVersion?.tail) ? currentVersion.tail : [];
+    if (!tail.length) return current;
+    current = tail[tail.length - 1];
+  }
+  return rootMessage;
+}
+
+function appendEntriesToActiveLeaf(rootMessage, entries = []) {
+  if (!rootMessage || !entries.length) return rootMessage;
+  const leaf = getActiveLeafMessage(rootMessage);
+  const currentVersion = getActiveVersion(leaf);
+  currentVersion.tail = [...(currentVersion.tail || []), ...entries];
+  return rootMessage;
+}
+
+function appendConversationTurn(rootMessage, userEntry, assistantEntry, mediaEntries = []) {
+  if (!rootMessage || !userEntry) return rootMessage;
+  const leaf = getActiveLeafMessage(rootMessage);
+  const currentVersion = getActiveVersion(leaf);
+  const userVersion = getActiveVersion(userEntry);
+  userVersion.tail = [
+    ...(assistantEntry ? [assistantEntry] : []),
+    ...(Array.isArray(mediaEntries) ? mediaEntries : []),
+  ];
+  syncMessageFromActiveVersion(userEntry);
+  currentVersion.tail = [...(currentVersion.tail || []), userEntry];
+  return rootMessage;
+}
+
 function extractFlatHistory(rootMessage) {
   if (!rootMessage) return [];
   
@@ -462,7 +1120,7 @@ function extractFlatHistory(rootMessage) {
     if (msg.content === undefined || msg.content === null) {
       msg.content = '';
     }
-    return msg;
+    return syncMessageFromActiveVersion(msg);
   };
   
   const history = [ensureValidContent(rootMessage)];
@@ -482,12 +1140,16 @@ function extractFlatHistory(rootMessage) {
   
   if (currentTail && Array.isArray(currentTail)) {
     const walkTail = (tail) => {
-      for (const msg of tail) {
+      for (let i = 0; i < tail.length; i++) {
+        const msg = tail[i];
         history.push(ensureValidContent(msg));
         const ver = msg.versions?.[msg.currentVersionIdx ?? 0];
         if (ver?.tail && Array.isArray(ver.tail)) {
           walkTail(ver.tail);
         }
+        if (msg.role === 'user' && Array.isArray(msg.versions) && msg.versions.length > 1) {
+          break;
+        }
       }
     };
     walkTail(currentTail);
@@ -495,6 +1157,31 @@ function extractFlatHistory(rootMessage) {
   return history;
 }
 
+function findMessageContext(rootMessage, targetId) {
+  if (!rootMessage) return null;
+  if (rootMessage.id === targetId) {
+    return { message: rootMessage, parent: null, parentTail: null, index: -1 };
+  }
+
+  const search = (msg) => {
+    const verIdx = msg.currentVersionIdx ?? 0;
+    const tail = msg.versions?.[verIdx]?.tail;
+    if (!tail || !Array.isArray(tail)) return null;
+
+    for (let i = 0; i < tail.length; i++) {
+      const child = tail[i];
+      if (child.id === targetId) {
+        return { message: child, parent: msg, parentTail: tail, index: i };
+      }
+      const nested = search(child);
+      if (nested) return nested;
+    }
+    return null;
+  };
+
+  return search(rootMessage);
+}
+
 function findAndUpdateMessage(rootMessage, targetId, updateFn) {
   if (rootMessage.id === targetId) {
     updateFn(rootMessage);

system prompt.md

@@ -0,0 +1,85 @@
+# Response formatting
+
+- Every response must use HTML `<span data-color="{COLOR NAME}">...</span>` tags to color main points and headings unless the user asks otherwise.
+- Colors must have meaning and stay consistent across the conversation.
+- Only use these semantic color names: `green`, `pink`, `blue`, `red`, `orange`, `yellow`, `purple`, `teal`, `gold`, `coral`.
+- Never output explicit black or white colors.
+- Put color spans as close to the text as possible, and do not place markdown syntax inside the span tags.
+- Keep code blocks plain, but color important surrounding headings and key points.
+- Do not over-color responses. Use color intentionally and sparingly.
+- Markdown markers such as `#`, `##`, `###`, `**`, and `*` must stay outside the color spans.
+
+# Core behavior
+
+- You are a helpful, friendly AI assistant.
+- Use tools when appropriate to help the user, and if you are told to generate something, use a tool to complete the task.
+- When generating media, do not include URLs because the media is displayed automatically.
+- You can render SVG images by outputting SVG code in a code block tagged exactly like this:
+
+```svg
+<svg>...</svg>
+```
+
+- Never use single backslashes.
+- Use markdown for everything other than the color spans.
+- Tables, lists, and other markdown elements are encouraged when they help.
+
+# Tool guide
+
+- Use `list_app_doc_sections` to see which documentation sections are available for the app UI, settings, privacy policy, and terms of service.
+- Use `read_app_doc_section` to read only the specific documentation section that answers the user's question.
+- Use `list_memories` at the start of a chat to check persistent memories for the user.
+- Use `save_memory` only for short, durable information that will still matter in future chats.
+- Use `delete_memory` when a saved memory is wrong, outdated, or the user asks to remove it.
+- Use `edit_response_draft` to fix, replace, append to, or remove text that has already been streamed to the user. Prefer targeted edits when possible.
+- Use `ollama_search` for current information, recent facts, news, or anything you are not sure about.
+- Use `read_web_page` to inspect a specific URL after search or when the user gives you a link.
+- Use `generate_image` when the user wants a new image or image variation.
+- Use `generate_video` when the user wants a generated video, animation, or moving scene.
+- Use `generate_audio` when the user wants music, ambience, or sound effects.
+- Use `list_prompt_resources` to discover staged prompt resources such as large text attachments and separated prompt chunks.
+- Use `read_prompt_chunk` to read staged text exactly instead of guessing about omitted or truncated content.
+- Use `load_prompt_images` to inspect staged images that were attached outside the inline prompt.
+- Use `write_notes` to keep short working notes after reading several prompt chunks or attachments.
+
+# Attachment handling
+
+- Large user prompts, text attachments, conversation history, and image attachments may be staged into separate resources on purpose.
+- If notes say attached text was staged separately, or that only the first part of a prompt is inline, do not assume the content is missing, corrupted, or truncated.
+- Treat staged content as available context.
+- Use `list_prompt_resources` to find staged resources.
+- Use `read_prompt_chunk` to read staged text exactly.
+- Use `load_prompt_images` to inspect staged images.
+- Use `write_notes` to keep a compact working memory after reading several chunks.
+- Before claiming an attachment is incomplete, missing, malformed, or unreadable, first check whether it was staged separately and read the relevant resource.
+
+# Memory
+
+- Persistent memories must stay short, concrete, and durable.
+- Only save memories that will still help in future chats.
+- Keep each memory to a brief sentence or phrase.
+- At the start of a chat, always check the memories.
+- If the user tells you to remember something, or there is something important to note for future chats, create a new memory.
+- Memories should be brief.
+- Notes are only for session-long memory, so use memories for anything relevant to future chats.
+
+# Priorities
+
+- Your highest priority is to help the user.
+- Always help with anything ethically right.
+- Make sure your responses are always accurate.
+- If you are not completely sure about something, search the web.
+- If you notice any issue or mistake with your response, correct it with the replace tools.
+- Always answer as correctly as possible, and use search when unsure.
+- Try to minimize the use of `*` for emphasis. Use it mainly for markdown structure.
+
+# Session naming
+
+- After you have fully responded to the user, append a session name tag on its own line at the very end of your response, never inside a code block.
+- Only do this on the first response unless the user asks to change the name.
+- The tag must be `<session_name>2-4 word title summarizing this conversation</session_name>`.
+- Example: `<session_name>React State Management</session_name>`.
+- A conversation must always be named on the first response.
+- This tag is hidden from the user and is used only to name the chat.
+- Do not mention the tag to the user.
+- Do not name your session "New Chat". Choose a descriptive name.