@coffer-org/plugin-webchat 6.0.0 → 7.0.1

package/dist/{ChatWidget-DFVDexpD.js → ChatWidget-DkEKl1-2.js}

@@ -1,5 +1,5 @@
 import * as __fedReact from "react";
-import { Dialog, DialogContent, classifySiteHref, uploadFile, useMinWidth } from "@coffer-org/web-ui";
+import { Dialog, DialogContent, Icon, classifySiteHref, toneVar, uploadFile, useMinWidth } from "@coffer-org/web-ui";
 import { createContext, createElement, forwardRef, memo, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { useLocation, useNavigate } from "react-router-dom";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
@@ -466,7 +466,7 @@ var useLucideContext = () => useContext(LucideContext);
 * This source code is licensed under the ISC license.
 * See the LICENSE file in the root directory of this source tree.
 */
-var Icon = forwardRef(({ color, size, strokeWidth, absoluteStrokeWidth, className = "", children, iconNode, ...rest }, ref) => {
+var Icon$1 = forwardRef(({ color, size, strokeWidth, absoluteStrokeWidth, className = "", children, iconNode, ...rest }, ref) => {
 	const { size: contextSize = 24, strokeWidth: contextStrokeWidth = 2, absoluteStrokeWidth: contextAbsoluteStrokeWidth = false, color: contextColor = "currentColor", className: contextClass = "" } = useLucideContext() ?? {};
 	const calculatedStrokeWidth = absoluteStrokeWidth ?? contextAbsoluteStrokeWidth ? Number(strokeWidth ?? contextStrokeWidth) * 24 / Number(size ?? contextSize) : strokeWidth ?? contextStrokeWidth;
 	return createElement("svg", {
@@ -490,7 +490,7 @@ var Icon = forwardRef(({ color, size, strokeWidth, absoluteStrokeWidth, classNam
 * See the LICENSE file in the root directory of this source tree.
 */
 var createLucideIcon = (iconName, iconNode) => {
-	const Component = forwardRef(({ className, ...props }, ref) => createElement(Icon, {
+	const Component = forwardRef(({ className, ...props }, ref) => createElement(Icon$1, {
 		ref,
 		iconNode,
 		className: mergeClasses(`lucide-${toKebabCase(toPascalCase(iconName))}`, `lucide-${iconName}`, className),
@@ -802,8 +802,9 @@ async function* readSse(body) {
 *  separate authorization here; the gate is on the server. */
 var BASE = "/api/plugins/webchat/user";
 /** POST a member-level webchat action with a JSON body: the one request path every call
-*  in this file (except the SSE stream in `sendMessage`) goes through. Throws `Error(action)`
-*  on any non-OK response — every caller below relies on that to build its own error message. */
+*  in this file (except the SSE stream in `openChannel` and `stopTurn`'s empty-body POST)
+*  goes through. Throws `Error(action)` on any non-OK response — every caller below relies
+*  on that to build its own error message. */
 async function postAction(action, body) {
 	const r = await fetch(`${BASE}/${action}`, {
 		method: "POST",
@@ -842,35 +843,98 @@ async function selectAgent(convId, patch) {
 		...patch
 	})).selection;
 }
+/** Mark a conversation private, or reopen it. Only ever meaningful for the
+*  caller's OWN conversation — the server refuses (returns the unchanged
+*  visibility) for anything else, so the UI only offers this control on the
+*  viewer's own rows in the first place. */
+async function setThreadVisibility(convId, makePrivate) {
+	return postAction("setVisibility", {
+		convId,
+		private: makePrivate
+	});
+}
+/** Records the user turn and starts the agent turn running — an ordinary POST that
+*  resolves as soon as the turn has STARTED, not once it finishes (`sendAction`,
+*  `../runtime/send.ts`). It streams nothing any more: every live update — the
+*  answer as it is written, its completion, an error — arrives on the
+*  conversation's own channel (`openChannel`, below), which `use-chat.ts` keeps
+*  open for as long as this conversation is on screen, whether or not THIS call
+*  is what started the turn currently running. */
 async function sendMessage(req) {
-	const r = await fetch(`${BASE}/send/stream`, {
+	return postAction("send", {
+		convId: req.convId,
+		text: req.text,
+		replyTo: req.replyTo,
+		context: req.context,
+		...req.attachments?.length ? { attachments: req.attachments } : {}
+	});
+}
+/** Abort the turn currently running on `convId`, if there is one (`stopAction`,
+*  `../runtime/actions.ts`). That action returns `Promise<void>` — the route sends
+*  an empty 200 body, the same uniform non-answer whether a live turn was
+*  actually aborted, none was running, or the caller may not write to the
+*  conversation — so this deliberately does NOT go through `postAction`, whose
+*  `.json()` would throw on that empty body. */
+async function stopTurn(convId) {
+	if (!(await fetch(`${BASE}/stop`, {
 		method: "POST",
 		headers: { "content-type": "application/json" },
-		body: JSON.stringify({
-			convId: req.convId,
-			text: req.text,
-			replyTo: req.replyTo,
-			context: req.context,
-			...req.attachments?.length ? { attachments: req.attachments } : {}
-		}),
-		signal: req.signal
+		body: JSON.stringify({ convId })
+	})).ok) throw new Error("stop");
+}
+/** Subscribe to `convId`'s channel and hold the connection open, delivering every
+*  frame to `handlers` until the server ends the stream (the conversation went
+*  private on this viewer, `setVisibility`'s eviction; a restart; a network drop)
+*  or `signal` aborts it. Resolves (does not reject) when the server ends the
+*  stream cleanly, same as a plain fetch whose body simply runs out — rejects only
+*  on a genuine transport failure or `signal` aborting. Either way it is
+*  `use-chat.ts`'s job to reconnect with backoff while the conversation is still
+*  the one on screen: there is no `Last-Event-ID` bookkeeping and no server-side
+*  buffer here, by design (see the design doc's "Reconnect, and the race that
+*  comes with it") — missed frames are recovered by re-reading history, never by
+*  replaying the stream. */
+async function openChannel(convId, handlers, signal) {
+	const r = await fetch(`${BASE}/channel/stream`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({ convId }),
+		signal
 	});
-	if (!r.ok || !r.body) {
-		req.onError(`http ${r.status}`);
-		return;
-	}
+	if (!r.ok || !r.body) throw new Error(`http ${r.status}`);
 	for await (const frame of readSse(r.body)) try {
 		const data = JSON.parse(frame.data);
-		if (frame.event === "reasoning") req.onReasoning?.(String(data["text"] ?? ""));
-		else if (frame.event === "delta" || frame.event === "message") req.onDelta(String(data["text"] ?? ""));
-		else if (frame.event === "done") req.onDone({
+		if (frame.event === "user") handlers.onUser({
+			msgId: String(data["msgId"] ?? ""),
+			text: String(data["text"] ?? ""),
+			ts: typeof data["ts"] === "number" ? data["ts"] : 0,
+			...Array.isArray(data["attachments"]) ? { attachments: data["attachments"] } : {}
+		});
+		else if (frame.event === "message") handlers.onMessage({
+			msgId: String(data["msgId"] ?? ""),
+			text: String(data["text"] ?? "")
+		});
+		else if (frame.event === "delta") handlers.onDelta({
+			msgId: String(data["msgId"] ?? ""),
+			text: String(data["text"] ?? "")
+		});
+		else if (frame.event === "reasoning") handlers.onReasoning({
+			msgId: String(data["msgId"] ?? ""),
+			text: String(data["text"] ?? "")
+		});
+		else if (frame.event === "done") handlers.onDone({
 			msgId: data["msgId"] ?? null,
 			parentMsgId: String(data["parentMsgId"] ?? ""),
 			suggestions: Array.isArray(data["suggestions"]) ? data["suggestions"] : null
 		});
-		else if (frame.event === "error") req.onError(String(data["message"] ?? "error"));
+		else if (frame.event === "error") handlers.onError({
+			message: data["message"] ?? null,
+			parentMsgId: typeof data["parentMsgId"] === "string" ? data["parentMsgId"] : null
+		});
 	} catch (e) {
-		req.onError(`malformed frame: ${String(e)}`);
+		handlers.onError({
+			message: `malformed frame: ${String(e)}`,
+			parentMsgId: null
+		});
 	}
 }
 //#endregion
@@ -878,6 +942,23 @@ async function sendMessage(req) {
 function newId() {
 	return crypto.randomUUID();
 }
+/** The message id a frame reports as its OUTCOME, for dedup against history on
+*  flush. `error` is never persisted (a failed turn stores nothing), so it is
+*  never a duplicate of anything a history read could carry — its
+*  `parentMsgId` exists only to scope the send-lock clear below to the
+*  viewer's own turn, a different question from dedup. */
+function frameHistoryId(frame) {
+	switch (frame.kind) {
+		case "user":
+		case "message":
+		case "delta":
+		case "reasoning": return frame.data.msgId;
+		case "done": return frame.data.msgId;
+		case "error": return null;
+	}
+}
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
 function useChat() {
 	const [threads, setThreads] = useState([]);
 	const [convId, setConvId] = useState(null);
@@ -894,15 +975,16 @@ function useChat() {
 	const [starters, setStarters] = useState([]);
 	const [suggestions, setSuggestions] = useState(null);
 	const headRef = useRef(null);
-	const abortRef = useRef(null);
 	const sendingRef = useRef(false);
+	const myTurnMsgIdRef = useRef(null);
+	const pendingTextRef = useRef("");
+	const pendingReasoningRef = useRef(null);
 	const turnRef = useRef(0);
 	const aliveRef = useRef(true);
 	useEffect(() => {
 		aliveRef.current = true;
 		return () => {
 			aliveRef.current = false;
-			abortRef.current?.abort();
 			turnRef.current++;
 		};
 	}, []);
@@ -925,6 +1007,157 @@ function useChat() {
 			cancelled = true;
 		};
 	}, [convId]);
+	/** Apply one channel frame to state. Called either live (as it arrives, once a
+	*  connection has finished its history flush) or from the buffer a fresh
+	*  (re)connect built while history was in flight — `historyIds` is non-null
+	*  ONLY for the latter, and gates every frame on it: a frame whose outcome the
+	*  just-fetched history already carries is dropped rather than reapplied, the
+	*  one piece of ordering the design doc calls out by name. Live frames never
+	*  need this check — their message id cannot already be in a history snapshot
+	*  read before they existed. */
+	const applyFrame = useCallback((frame, historyIds) => {
+		const outcomeId = frameHistoryId(frame);
+		const isDuplicate = historyIds !== null && outcomeId !== null && historyIds.has(outcomeId);
+		switch (frame.kind) {
+			case "user": {
+				if (isDuplicate) break;
+				const { msgId, text, ts, attachments } = frame.data;
+				setMessages((prev) => prev.some((m) => m.msgId === msgId) ? prev : [...prev, {
+					msgId,
+					role: "user",
+					text,
+					ts,
+					...attachments?.length ? { attachments } : {}
+				}]);
+				break;
+			}
+			case "message":
+			case "delta":
+				if (isDuplicate) break;
+				pendingTextRef.current = frame.data.text;
+				setPending(frame.data.text);
+				break;
+			case "reasoning":
+				if (isDuplicate) break;
+				pendingReasoningRef.current = frame.data.text;
+				setPendingReasoning(frame.data.text);
+				break;
+			case "done": {
+				const { msgId, parentMsgId, suggestions: nextSuggestions } = frame.data;
+				headRef.current = msgId ?? parentMsgId;
+				setSuggestions(nextSuggestions ?? null);
+				if (!isDuplicate && msgId && pendingTextRef.current) {
+					const text = pendingTextRef.current;
+					const reasoning = pendingReasoningRef.current;
+					setMessages((prev) => prev.some((m) => m.msgId === msgId) ? prev : [...prev, {
+						msgId,
+						role: "assistant",
+						text,
+						ts: Math.floor(Date.now() / 1e3),
+						...reasoning ? { reasoning } : {}
+					}]);
+				}
+				pendingTextRef.current = "";
+				pendingReasoningRef.current = null;
+				setPending(null);
+				setPendingReasoning(null);
+				if (myTurnMsgIdRef.current !== null && myTurnMsgIdRef.current === parentMsgId) {
+					sendingRef.current = false;
+					myTurnMsgIdRef.current = null;
+				}
+				loadThreads();
+				break;
+			}
+			case "error":
+				setError(frame.data.message ?? "error");
+				pendingTextRef.current = "";
+				pendingReasoningRef.current = null;
+				setPending(null);
+				setPendingReasoning(null);
+				if (myTurnMsgIdRef.current !== null && myTurnMsgIdRef.current === frame.data.parentMsgId) {
+					sendingRef.current = false;
+					myTurnMsgIdRef.current = null;
+				}
+				break;
+		}
+	}, [loadThreads]);
+	useEffect(() => {
+		if (!convId) return;
+		const chatConvId = convId;
+		let cancelled = false;
+		let reconnectTimer = null;
+		let attempt = 0;
+		const ctl = new AbortController();
+		async function connectOnce() {
+			if (cancelled) return;
+			let buffering = true;
+			let receivedFrame = false;
+			const buffer = [];
+			const dispatch = (frame) => {
+				if (cancelled) return;
+				receivedFrame = true;
+				if (buffering) buffer.push(frame);
+				else applyFrame(frame, null);
+			};
+			const settled = openChannel(chatConvId, {
+				onUser: (data) => dispatch({
+					kind: "user",
+					data
+				}),
+				onMessage: (data) => dispatch({
+					kind: "message",
+					data
+				}),
+				onDelta: (data) => dispatch({
+					kind: "delta",
+					data
+				}),
+				onReasoning: (data) => dispatch({
+					kind: "reasoning",
+					data
+				}),
+				onDone: (data) => dispatch({
+					kind: "done",
+					data
+				}),
+				onError: (data) => dispatch({
+					kind: "error",
+					data
+				})
+			}, ctl.signal).then(() => true, () => false);
+			try {
+				const h = await fetchHistory(chatConvId);
+				if (cancelled) return;
+				headRef.current = h.headMsgId;
+				const historyIds = new Set(h.messages.map((m) => m.msgId));
+				setMessages((prev) => {
+					const ownPendingId = myTurnMsgIdRef.current;
+					const stillUnconfirmed = prev.filter((m) => !historyIds.has(m.msgId) && (m.msgId.startsWith("local-") || m.msgId === ownPendingId));
+					return stillUnconfirmed.length ? [...h.messages, ...stillUnconfirmed] : h.messages;
+				});
+				setSuggestions(h.messages.at(-1)?.suggestions ?? null);
+				buffering = false;
+				for (const frame of buffer) applyFrame(frame, historyIds);
+			} catch (e) {
+				if (cancelled) return;
+				setError(e.message);
+				buffering = false;
+				for (const frame of buffer) applyFrame(frame, null);
+			}
+			await settled;
+			if (cancelled) return;
+			if (receivedFrame) attempt = 0;
+			const delay = Math.min(RECONNECT_BASE_MS * 2 ** attempt, RECONNECT_MAX_MS);
+			attempt++;
+			reconnectTimer = setTimeout(() => void connectOnce(), delay);
+		}
+		connectOnce();
+		return () => {
+			cancelled = true;
+			if (reconnectTimer) clearTimeout(reconnectTimer);
+			ctl.abort();
+		};
+	}, [convId, applyFrame]);
 	const chooseAgent = useCallback((next) => {
 		const previous = selection;
 		setSelection(next);
@@ -933,52 +1166,61 @@ function useChat() {
 			setError(err instanceof Error ? err.message : String(err));
 		});
 	}, [convId, selection]);
+	const togglePrivate = useCallback((convId, next) => {
+		const previous = threads.find((t) => t.convId === convId)?.private ?? false;
+		setThreads((prev) => prev.map((t) => t.convId === convId ? {
+			...t,
+			private: next
+		} : t));
+		setThreadVisibility(convId, next).then((r) => {
+			setThreads((prev) => prev.map((t) => t.convId === convId ? {
+				...t,
+				private: r.visibility === "private"
+			} : t));
+		}).catch(() => {
+			setThreads((prev) => prev.map((t) => t.convId === convId ? {
+				...t,
+				private: previous
+			} : t));
+		});
+	}, [threads]);
 	const attachmentsAllowed = useMemo(() => {
-		const preset = agents.find((a) => a.id === selection.agentId)?.presets.find((p) => p.id === selection.presetId);
-		if (!preset?.capabilities) return true;
-		return preset.capabilities.vision !== false || preset.capabilities.documents !== false;
+		const media = agents.find((a) => a.id === selection.agentId)?.media;
+		if (!media) return true;
+		return media.image.accepts.length > 0 || media.document.accepts.length > 0;
 	}, [agents, selection]);
 	const newConversation = useCallback(() => {
-		abortRef.current?.abort();
-		abortRef.current = null;
 		turnRef.current++;
+		sendingRef.current = false;
+		myTurnMsgIdRef.current = null;
 		headRef.current = null;
 		setConvId(newId());
 		setMessages([]);
 		setPending(null);
 		setPendingReasoning(null);
+		pendingTextRef.current = "";
+		pendingReasoningRef.current = null;
 		setError(null);
 		setSuggestions(null);
 	}, []);
 	const open = useCallback(async (id) => {
-		abortRef.current?.abort();
-		abortRef.current = null;
 		turnRef.current++;
-		const myTurn = turnRef.current;
+		sendingRef.current = false;
+		myTurnMsgIdRef.current = null;
 		setConvId(id);
-		setMessages([]);
 		headRef.current = null;
+		setMessages([]);
 		setPending(null);
 		setPendingReasoning(null);
+		pendingTextRef.current = "";
+		pendingReasoningRef.current = null;
 		setError(null);
 		setSuggestions(null);
-		try {
-			const h = await fetchHistory(id);
-			if (turnRef.current !== myTurn) return;
-			headRef.current = h.headMsgId;
-			setMessages(h.messages);
-			setSuggestions(h.messages.at(-1)?.suggestions ?? null);
-		} catch (e) {
-			if (turnRef.current !== myTurn) return;
-			setError(e.message);
-		}
 	}, []);
 	const stop = useCallback(() => {
-		abortRef.current?.abort();
-		abortRef.current = null;
-		setPending(null);
-		setPendingReasoning(null);
-	}, []);
+		if (!convId) return;
+		stopTurn(convId).catch(() => {});
+	}, [convId]);
 	return {
 		threads,
 		convId,
@@ -993,6 +1235,7 @@ function useChat() {
 		suggestions,
 		attachmentsAllowed,
 		chooseAgent,
+		togglePrivate,
 		send: useCallback((text, context, attachments = []) => {
 			if (!text.trim() || sendingRef.current) return false;
 			sendingRef.current = true;
@@ -1001,74 +1244,47 @@ function useChat() {
 			if (convId === null) setConvId(id);
 			setError(null);
 			setSuggestions(null);
+			const localMsgId = `local-${newId()}`;
 			setMessages((prev) => [...prev, {
-				msgId: `local-${newId()}`,
+				msgId: localMsgId,
 				role: "user",
 				text,
 				ts: Math.floor(Date.now() / 1e3),
 				...attachments.length ? { attachments } : {}
 			}]);
 			setPending("");
-			const ctl = new AbortController();
-			abortRef.current = ctl;
-			let acc = "";
-			let accReasoning = "";
 			(async () => {
 				try {
-					await sendMessage({
+					const { msgId } = await sendMessage({
 						convId: id,
 						text,
 						replyTo: headRef.current,
 						context,
-						attachments,
-						signal: ctl.signal,
-						onDelta: (t) => {
-							if (turnRef.current !== myTurn) return;
-							acc = t;
-							setPending(t);
-						},
-						onReasoning: (t) => {
-							if (turnRef.current !== myTurn) return;
-							accReasoning = t;
-							setPendingReasoning(t);
-						},
-						onDone: ({ msgId, parentMsgId, suggestions: nextSuggestions }) => {
-							if (turnRef.current !== myTurn) return;
-							headRef.current = msgId ?? parentMsgId;
-							setSuggestions(nextSuggestions ?? null);
-							if (acc) setMessages((prev) => [...prev, {
-								msgId: msgId ?? `local-${newId()}`,
-								role: "assistant",
-								text: acc,
-								ts: Math.floor(Date.now() / 1e3),
-								...accReasoning ? { reasoning: accReasoning } : {}
-							}]);
-							setPending(null);
-							setPendingReasoning(null);
-						},
-						onError: (message) => {
-							if (turnRef.current !== myTurn) return;
-							setError(message);
-							setPending(null);
-							setPendingReasoning(null);
-						}
+						attachments
 					});
-				} catch (e) {
-					if (turnRef.current === myTurn) {
-						if (e.name !== "AbortError") setError(e.message);
+					if (turnRef.current !== myTurn) return;
+					if (msgId === null) {
+						sendingRef.current = false;
 						setPending(null);
 						setPendingReasoning(null);
+						return;
 					}
-				} finally {
-					sendingRef.current = false;
+					setMessages((prev) => prev.some((m) => m.msgId === msgId) ? prev.filter((m) => m.msgId !== localMsgId) : prev.map((m) => m.msgId === localMsgId ? {
+						...m,
+						msgId
+					} : m));
+					myTurnMsgIdRef.current = msgId;
+				} catch (e) {
 					if (turnRef.current === myTurn) {
-						abortRef.current = null;
-						loadThreads();
+						sendingRef.current = false;
+						setError(e.message);
+						setPending(null);
+						setPendingReasoning(null);
 					}
 				}
 			})();
 			return true;
-		}, [convId, loadThreads]),
+		}, [convId]),
 		open,
 		newConversation,
 		loadThreads,
@@ -1077,10 +1293,47 @@ function useChat() {
 }
 //#endregion
 //#region src/ui/use-page-context.ts
-/** Current-page context for the agent. SPA routes: `/:library/:type[/:id]`;
-*  system branches (settings, browse) are returned by path only. */
-function usePageContext() {
-	const { pathname } = useLocation();
+/** The record page's own heading — a BEST-EFFORT read of the app's own rendered DOM,
+*  not a data path. `RecordContent` (`packages/web/display/index.tsx`) marks the
+*  TITLE element itself `role="heading" aria-level="1"` (the row around it, which also
+*  holds the avatar, carries no role — otherwise the avatar's own text would be read
+*  as part of the name); today that is the only element in the whole app carrying it,
+*  so this selector cannot pick up some OTHER record's heading by mistake. It exists at
+*  all because the chat overlay is a sibling of the routed page (mounted in the app
+*  shell's own slot), never a descendant of it, so there is no React tree — no prop, no
+*  context — to read the value from, and this package (`plugin-webchat`) has no data
+*  path of its own to the open record either. Reading the painted DOM instead of
+*  fetching the record: the SPA already has it open and displaying this text, and a
+*  server-side lookup would be a query per turn for a value the browser is holding.
+*
+*  WHEN it is read is the whole safety argument, so it is stated rather than assumed:
+*  reading the DOM during React's RENDER phase sees the PREVIOUSLY COMMITTED tree, so a
+*  navigation from one record to another produced the new path and id beside the OLD
+*  record's name — a fact stated WRONG, which the base prompt tells the model to trust.
+*  Hence `usePageContext` returns a READER the composer calls in its send handler: an
+*  event handler runs after commit, so the heading and the path it is reported with
+*  come from the same painted page. That is also what the design asks for — the page
+*  the user was on AT THE MOMENT OF SENDING, and nowhere else.
+*
+*  What is guaranteed, then: the title is read from the DOM as it stands when the turn
+*  is sent. What is NOT guaranteed is that the title is present — a heading not yet
+*  painted (a record still loading) and an untitled record's Dash placeholder both
+*  yield no title, and an absent fact is the harmless case. One case yields a WRONG
+*  one: if the app ever grows a SECOND element with this exact role/level (a preview
+*  dialog, a relation picker, a plugin's own record renderer), `querySelector` returns
+*  whichever comes first in document order, not necessarily the record the user is
+*  actually looking at. Whoever eventually gives the overlay a real data path to the
+*  open record should read this as the reason it was ever DOM-based, not rediscover it. */
+var EMPTY_TITLE = "—";
+function recordHeading() {
+	if (typeof document === "undefined") return void 0;
+	const text = document.querySelector("[role=\"heading\"][aria-level=\"1\"]")?.textContent?.trim();
+	return text && text !== EMPTY_TITLE ? text : void 0;
+}
+/** SPA routes: `/:library/:type[/:id]`; system branches (settings, browse) are
+*  returned by path only. Pure but for the heading read, which is why it takes the
+*  path rather than calling the router itself. */
+function pageContextAt(pathname) {
 	const parts = pathname.split("/").filter(Boolean);
 	const system = /* @__PURE__ */ new Set([
 		"settings",
@@ -1091,13 +1344,25 @@ function usePageContext() {
 	]);
 	if (parts.length < 2 || system.has(parts[0])) return { path: pathname };
 	const [library, type, id] = parts;
+	const isRecord = Boolean(id && id !== "new");
+	const title = isRecord ? recordHeading() : void 0;
 	return {
 		path: pathname,
 		library,
 		type,
-		...id && id !== "new" ? { id } : {}
+		...isRecord ? { id } : {},
+		...title ? { title } : {}
 	};
 }
+/** Current-page context for the agent, as a reader called AT SEND TIME rather than a
+*  value computed while rendering — see the heading comment above for why that
+*  distinction is the difference between an absent title and a wrong one. The path
+*  comes from the render that is currently committed, which is the same tree the
+*  reader's heading lookup walks. */
+function usePageContext() {
+	const { pathname } = useLocation();
+	return useCallback(() => pageContextAt(pathname), [pathname]);
+}
 //#endregion
 //#region ../../node_modules/devlop/lib/development.js
 var AssertionError = class extends Error {
@@ -23819,11 +24084,11 @@ function ChatMessages({ messages, pending, pendingReasoning, trailing }) {
 var Bubble = memo(function Bubble({ role, text, reasoning, attachments }) {
 	const { t } = useTranslation();
 	if (role === "user") return /* @__PURE__ */ jsxs("div", {
-		className: "self-end max-w-[85%] rounded-2xl bg-accent/15 px-3 py-2 text-[0.8125rem] whitespace-pre-wrap break-words",
+		className: "self-end max-w-[85%] rounded-2xl border border-accent bg-elevated px-3 py-2 text-[0.8125rem] whitespace-pre-wrap break-words",
 		children: [attachments?.length ? /* @__PURE__ */ jsx("div", {
 			className: "mb-1.5 flex flex-wrap gap-1",
 			children: attachments.map((a) => /* @__PURE__ */ jsx("span", {
-				className: "inline-flex max-w-full items-center rounded-md bg-bg/60 px-1.5 py-0.5 text-xs",
+				className: "inline-flex max-w-full items-center rounded-md bg-bg px-1.5 py-0.5 text-xs",
 				title: a.name,
 				children: a.label ?? a.name
 			}, a.name))
@@ -23984,7 +24249,8 @@ function AgentPicker({ agents, defaultAgentId, selection, onChange }) {
 					children: /* @__PURE__ */ jsx(Star, {
 						size: 16,
 						"aria-hidden": true,
-						className: n <= shown ? "fill-yellow-400 text-yellow-400" : "text-border"
+						className: n <= shown ? "fill-current" : "text-border",
+						style: n <= shown ? { color: toneVar("yellow") } : void 0
 					})
 				}) }, `${r.agentId}/${r.presetId}`);
 			})
@@ -24177,7 +24443,7 @@ function ChatComposer({ streaming, onSend, onStop, attachments, uploading, uploa
 }
 //#endregion
 //#region src/ui/ChatThreadList.tsx
-function ChatThreadList({ threads, activeId, onOpen, onNew, className = "w-[220px] shrink-0" }) {
+function ChatThreadList({ threads, activeId, onOpen, onNew, onTogglePrivate, className = "w-[220px] shrink-0" }) {
 	const { t } = useTranslation();
 	return /* @__PURE__ */ jsxs("aside", {
 		"aria-label": t("webchat.threads"),
@@ -24192,11 +24458,36 @@ function ChatThreadList({ threads, activeId, onOpen, onNew, className = "w-[220p
 			]
 		}), /* @__PURE__ */ jsx("div", {
 			className: "flex-1 overflow-y-auto",
-			children: threads.map((th) => /* @__PURE__ */ jsx("button", {
-				onClick: () => onOpen(th.convId),
-				className: `block w-full truncate px-3 py-2 text-left text-sm hover:bg-elevated ${th.convId === activeId ? "bg-elevated font-medium" : ""}`,
-				children: th.title || t("webchat.newConversation")
-			}, th.convId))
+			children: threads.map((th) => {
+				const active = th.convId === activeId;
+				return /* @__PURE__ */ jsxs("div", {
+					className: `flex items-center gap-1 pl-1 pr-2 ${active ? "bg-elevated" : "hover:bg-elevated"}`,
+					children: [/* @__PURE__ */ jsxs("button", {
+						onClick: () => onOpen(th.convId),
+						className: `min-w-0 flex-1 py-2 pl-2 text-left text-sm ${active ? "font-medium" : ""}`,
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "block truncate",
+							children: th.title || t("webchat.newConversation")
+						}), (th.mine || th.ownerName) && /* @__PURE__ */ jsx("span", {
+							className: "block truncate text-xs text-muted",
+							children: th.mine ? t("webchat.you") : th.ownerName
+						})]
+					}), th.mine && /* @__PURE__ */ jsx("button", {
+						type: "button",
+						"aria-label": th.private ? t("webchat.makePublic") : t("webchat.makePrivate"),
+						title: th.private ? t("webchat.makePublic") : t("webchat.makePrivate"),
+						onClick: (e) => {
+							e.stopPropagation();
+							onTogglePrivate(th.convId, !th.private);
+						},
+						className: "shrink-0 rounded p-1 text-muted hover:bg-surface hover:text-text focus-visible:outline-2 focus-visible:outline-accent",
+						children: /* @__PURE__ */ jsx(Icon, {
+							name: th.private ? "lucide:shield" : "lucide:globe",
+							size: 14
+						})
+					})]
+				}, th.convId);
+			})
 		})]
 	});
 }
@@ -24271,7 +24562,7 @@ function ChatDropSurface({ children, onFiles, className }) {
 			"data-testid": "chat-drop-overlay",
 			className: "pointer-events-none absolute inset-0 z-50 grid place-items-center bg-surface/95 p-6 text-center backdrop-blur-sm",
 			children: /* @__PURE__ */ jsxs("div", {
-				className: "flex h-full w-full flex-col items-center justify-center rounded-2xl border-2 border-dashed border-accent bg-accent/10 text-accent",
+				className: "flex h-full w-full flex-col items-center justify-center rounded-2xl border-2 border-dashed border-accent text-accent",
 				children: [
 					/* @__PURE__ */ jsx(Upload, { size: 34 }),
 					/* @__PURE__ */ jsx("span", {
@@ -24316,7 +24607,7 @@ function stepMode(mode, wide, delta) {
 function ChatWidget() {
 	const { t } = useTranslation();
 	const chat = useChat();
-	const page = usePageContext();
+	const readPage = usePageContext();
 	const [mode, setMode] = useState("bubble");
 	const [threadsOpen, setThreadsOpen] = useState(false);
 	const [attachments, setAttachments] = useState([]);
@@ -24413,6 +24704,7 @@ function ChatWidget() {
 		if (retryFiles.length) pickFiles(retryFiles);
 	}, [pickFiles, retryFiles]);
 	const sendTurn = useCallback((text, refs) => {
+		const page = readPage();
 		const accepted = refs.length ? chat.send(text, page, refs) : chat.send(text, page);
 		if (accepted) {
 			setAttachments([]);
@@ -24420,7 +24712,7 @@ function ChatWidget() {
 			setRetryFiles([]);
 		}
 		return accepted;
-	}, [chat, page]);
+	}, [chat, readPage]);
 	const hasConversation = chat.messages.length > 0 || chat.pending !== null;
 	const header = /* @__PURE__ */ jsxs("div", {
 		className: "flex shrink-0 items-center justify-between border-b border-border px-3 py-2",
@@ -24504,7 +24796,7 @@ function ChatWidget() {
 	if (mode === "bubble") return /* @__PURE__ */ jsx("button", {
 		"aria-label": t("webchat.open"),
 		onClick: () => setMode(restingMode(wide)),
-		className: "fixed bottom-20 right-4 z-40 grid h-14 w-14 place-items-center rounded-full bg-accent text-white shadow-lg nav:bottom-4",
+		className: "fixed bottom-20 right-4 z-40 grid h-14 w-14 place-items-center rounded-full bg-accent text-on-accent ring-1 ring-border2 shadow-lg nav:bottom-4",
 		children: /* @__PURE__ */ jsx(MessageCircle, { size: 24 })
 	});
 	if (mode === "panel") return /* @__PURE__ */ jsxs(ChatDropSurface, {
@@ -24541,6 +24833,7 @@ function ChatWidget() {
 								setThreadsOpen(false);
 							},
 							onNew: startNew,
+							onTogglePrivate: chat.togglePrivate,
 							className: wide ? "w-[220px] shrink-0" : "w-full"
 						}), (wide || !threadsOpen) && conversation]
 					})]