ruflo 3.6.27 → 3.6.28

package/src/ruvocal/.claude-flow/logs/headless/optimize_1777949531823_yt5yc2_prompt.log

@@ -0,0 +1,1498 @@
+[2026-05-05T02:52:11.834Z] PROMPT
+============================================================
+Analyze this codebase for performance optimizations:
+- Identify N+1 query patterns
+- Find unnecessary re-renders in React
+- Suggest caching opportunities
+- Identify memory leaks
+- Find redundant computations
+
+Provide actionable suggestions with code examples.
+
+## Codebase Context
+
+--- src/ambient.d.ts ---
+declare module "*.ttf" {
+	const value: ArrayBuffer;
+	export default value;
+}
+
+// Legacy helpers removed: web search support is deprecated, so we intentionally
+// avoid leaking those shapes into the global ambient types.
+
+
+--- src/app.d.ts ---
+/// <reference types="@sveltejs/kit" />
+/// <reference types="unplugin-icons/types/svelte" />
+
+import type { User } from "$lib/types/User";
+
+// See https://kit.svelte.dev/docs/types#app
+// for information about these interfaces
+declare global {
+	namespace App {
+		// interface Error {}
+		interface Locals {
+			sessionId: string;
+			user?: User;
+			isAdmin: boolean;
+			token?: string;
+			/** Organization to bill inference requests to (from settings) */
+			billingOrganization?: string;
+		}
+
+		interface Error {
+			message: string;
+			errorId?: ReturnType<typeof crypto.randomUUID>;
+		}
+		// interface PageData {}
+		// interface Platform {}
+	}
+}
+
+export {};
+
+
+--- src/hooks.server.ts ---
+import { building } from "$app/environment";
+import type { Handle, HandleServerError, ServerInit, HandleFetch } from "@sveltejs/kit";
+import { initServer } from "$lib/server/hooks/init";
+import { handleRequest } from "$lib/server/hooks/handle";
+import { handleServerError } from "$lib/server/hooks/error";
+import { handleFetchRequest } from "$lib/server/hooks/fetch";
+
+export const init: ServerInit = async () => {
+	if (building) return;
+	return initServer();
+};
+
+export const handle: Handle = async (input) => {
+	if (building) {
+		// During static build, still replace %gaId% placeholder with empty string
+		// to prevent the GA script from loading with an invalid ID
+		return input.resolve(input.event, {
+			transformPageChunk: ({ html }) => html.replace("%gaId%", ""),
+		});
+	}
+	return handleRequest(input);
+};
+
+export const handleError: HandleServerError = async (input) => {
+	if (building) throw input.error;
+	return handleServerError(input);
+};
+
+export const handleFetch: HandleFetch = async (input) => {
+	if (building) return input.fetch(input.request);
+	return handleFetchRequest(input);
+};
+
+
+--- src/hooks.ts ---
+import { publicConfigTransporter } from "$lib/utils/PublicConfig.svelte";
+import type { Transport } from "@sveltejs/kit";
+
+export const transport: Transport = {
+	PublicConfig: publicConfigTransporter,
+};
+
+
+--- src/lib/APIClient.ts ---
+import { base } from "$app/paths";
+import { browser } from "$app/environment";
+import superjson from "superjson";
+import ObjectId from "bson-objectid";
+
+superjson.registerCustom<ObjectId, string>(
+	{
+		isApplicable: (value): value is ObjectId => {
+			if (typeof value !== "string" && ObjectId.isValid(value)) {
+				const str = value.toString();
+				return /^[0-9a-fA-F]{24}$/.test(str);
+			}
+			return false;
+		},
+		serialize: (value) => value.toString(),
+		deserialize: (value) => new ObjectId(value),
+	},
+	"ObjectId"
+);
+
+type FetchFn = typeof globalThis.fetch;
+
+interface ApiResponse<T = unknown> {
+	data: T | null;
+	error: unknown;
+	status: number;
+}
+
+async function apiCall<T = unknown>(
+	fetcher: FetchFn,
+	url: string,
+	method: string,
+	body?: unknown,
+	query?: Record<string, string | number | undefined>
+): Promise<ApiResponse<T>> {
+	const u = new URL(url);
+	if (query) {
+		for (const [k, v] of Object.entries(query)) {
+			if (v !== undefined && v !== null) {
+				u.searchParams.set(k, String(v));
+			}
+		}
+	}
+
+	const init: RequestInit = { method };
+	if (body !== undefined && body !== null) {
+		init.headers = { "Content-Type": "application/json" };
+		init.body = JSON.stringify(body);
+	}
+
+	const res = await fetcher(u.toString(), init);
+	if (!res.ok) {
+		let errorBody: unknown;
+		try {
+			errorBody = await res.json();
+		} catch {
+			errorBody = await res.text().catch(() => res.statusText);
+		}
+		return { data: null, error: errorBody, status: res.status };
+	}
+
+	// Handle empty responses (e.g. POST /user/settings returns empty body)
+	const text = await res.text();
+	if (!text) {
+		return { data: null, error: null, status: res.status };
+	}
+
+	return { data: text as unknown as T, error: null, status: res.status };
+}
+
+function endpoint(fetcher: FetchFn, baseUrl: string) {
+	return {
+		get(opts?: { query?: Record<string, string | number | undefined> }) {
+			return apiCall(fetcher, baseUrl, "GET", undefined, opts?.query);
+		},
+		post(body?: unknown) {
+			return apiCall(fetcher, baseUrl, "POST", body);
+		},
+		patch(body?: unknown) {
+			return apiCall(fetcher, baseUrl, "PATCH", body);
+		},
+		delete() {
+			return apiCall(fetcher, baseUrl, "DELETE");
+		},
+	};
+}
+
+export function useAPIClient({
+	fetch: customFetch,
+	origin,
+}: {
+	fetch?: FetchFn;
+	origin?: string;
+} = {}) {
+	const fetcher = customFetch ?? globalThis.fetch;
+	const baseUrl = browser
+		? `${window.location.origin}${base}/api/v2`
+		: `${origin ?? `http://localhost:5173`}${base}/api/v2`;
+
+	return {
+		conversations: Object.assign(
+			// client.conversations({ id: "..." }) — returns endpoint for /conversations/:id
+			(params: { id: string }) => ({
+				...endpoint(fetcher, `${baseUrl}/conversations/${params.id}`),
+				message: (msgParams: { messageId: string }) =>
+					endpoint(fetcher, `${baseUrl}/conversations/${params.id}/message/${msgParams.messageId}`),
+			}),
+			// client.conversations.get(), .delete()
+			{
+				...endpoint(fetcher, `${baseUrl}/conversations`),
+				"import-share": endpoint(fetcher, `${baseUrl}/conversations/import-share`),
+			}
+		),
+		user: {
+			...endpoint(fetcher, `${baseUrl}/user`),
+			settings: endpoint(fetcher, `${baseUrl}/user/settings`),
+			reports: endpoint(fetcher, `${baseUrl}/user/reports`),
+			"billing-orgs": endpoint(fetcher, `${baseUrl}/user/billing-orgs`),
+		},
+		models: {
+			...endpoint(fetcher, `${baseUrl}/models`),
+			old: endpoint(fetcher, `${baseUrl}/models/old`),
+			refresh: endpoint(fetcher, `${baseUrl}/models/refresh`),
+		},
+		"public-config": endpoint(fetcher, `${baseUrl}/public-config`),
+		"feature-flags": endpoint(fetcher, `${baseUrl}/feature-flags`),
+		debug: {
+			config: endpoint(fetcher, `${baseUrl}/debug/config`),
+			refresh: endpoint(fetcher, `${baseUrl}/debug/refresh`),
+		},
+		export: endpoint(fetcher, `${baseUrl}/export`),
+	};
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function handleResponse(response: ApiResponse<any>): any {
+	if (response.error) {
+		throw new Error(JSON.stringify(response.error));
+	}
+
+	if (response.data === null) {
+		return null;
+	}
+
+	return superjson.parse(
+		typeof response.data === "string" ? response.data : JSON.stringify(response.data)
+	);
+}
+
+
+--- src/lib/actions/clickOutside.ts ---
+export function clickOutside(element: HTMLElement, callbackFunction: () => void) {
+	function onClick(event: MouseEvent) {
+		if (!element.contains(event.target as Node)) {
+			callbackFunction();
+		}
+	}
+
+	document.body.addEventListener("click", onClick);
+
+	return {
+		update(newCallbackFunction: () => void) {
+			callbackFunction = newCallbackFunction;
+		},
+		destroy() {
+			document.body.removeEventListener("click", onClick);
+		},
+	};
+}
+
+
+--- src/lib/actions/snapScrollToBottom.ts (truncated) ---
+import { navigating } from "$app/state";
+import { tick } from "svelte";
+
+// Threshold to determine if user is "at bottom" - larger value prevents false detachment
+const BOTTOM_THRESHOLD = 50;
+const USER_SCROLL_DEBOUNCE_MS = 150;
+const PROGRAMMATIC_SCROLL_GRACE_MS = 100;
+const TOUCH_DETACH_THRESHOLD_PX = 10;
+
+interface ScrollDependency {
+	signal: unknown;
+	forceReattach?: number;
+}
+
+type MaybeScrollDependency = ScrollDependency | unknown;
+
+const getForceReattach = (value: MaybeScrollDependency): number => {
+	if (typeof value === "object" && value !== null && "forceReattach" in value) {
+		return (value as ScrollDependency).forceReattach ?? 0;
+	}
+	return 0;
+};
+
+/**
+ * Auto-scroll action that snaps to bottom while respecting user scroll intent.
+ *
+ * Key behaviors:
+ * 1. Uses wheel/touch events to detect actual user intent
+ * 2. Uses IntersectionObserver on a sentinel element to reliably detect "at bottom" state
+ * 3. Larger threshold to prevent edge-case false detachments
+ *
+ * @param node element to snap scroll to bottom
+ * @param dependency pass in { signal, forceReattach } - signal triggers scroll updates,
+ *                   forceReattach (counter) forces re-attachment when incremented
+ */
+export const snapScrollToBottom = (node: HTMLElement, dependency: MaybeScrollDependency) => {
+	// --- State ----------------------------------------------------------------
+
+	// Track whether user has intentionally scrolled away from bottom
+	let isDetached = false;
+
+	// Track the last forceReattach value to detect changes
+	let lastForceReattach = getForceReattach(dependency);
+
+	// Track if user is actively scrolling (via wheel/touch)
+	let userScrolling = false;
+	let userScrollTimeout: ReturnType<typeof setTimeout> | undefined;
+
+	// Track programmatic scrolls to avoid treating them as user scrolls
+	let isProgrammaticScroll = false;
+	let lastProgrammaticScrollTime = 0;
+
+	// Track previous scroll position to detect scrollbar drags
+	let prevScrollTop = node.scrollTop;
+
+	// Touch handling state
+	let touchStartY = 0;
+
+	// Observers and sentinel
+	let resizeObserver: ResizeObserver | undefined;
+	let intersectionObserver: IntersectionObserver | undefined;
+	let sentinel: HTMLDivElement | undefined;
+
+	// Track content height for early-return optimization during streaming
+	let lastScrollHeight = node.scrollHeight;
+
+	// --- Helpers --------------------------------------------------------------
+
+	const clearUserScrollTimeout = () => {
+		if (userScrollTimeout) {
+			clearTimeout(userScrollTimeout);
+			userScrollTimeout = undefined;
+		}
+	};
+
+	const distanceFromBottom = () => node.scrollHeight - node.scrollTop - node.clientHeight;
+
+	const isAtBottom = () => distanceFromBottom() <= BOTTOM_THRESHOLD;
+
+	const scrollToBottom = () => {
+		isProgrammaticScroll = true;
+		lastProgrammaticScrollTime = Date.now();
+
+		node.scrollTo({ top: node.scrollHeight });
+
+		if (typeof requestAnimationFrame === "function") {
+			requestAnimationFrame(() => {
+				isProgrammaticScroll = false;
+			});
+		} else {
+			isProgrammaticScroll = false;
+		}
+	};
+
+	const settleScrollAfterLayout = async () => {
+		if (typeof requestAnimationFrame !== "function") return;
+
+		const raf = () => new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+
+		await raf();
+		if (!userScrolling && !isDetached) {
+			scrollToBottom();
+		}
+
+		await raf();
+		if (!userScrolling && !isDetached) {
+			scrollToBottom();
+		}
+	};
+
+	const scheduleUserScrollEndCheck = () => {
+		userScrolling = true;
+		clearUserScrollTimeout();
+
+		userScrollTimeout = setTimeout(() => {
+			userScrolling = false;
+
+			// If user scrolled back to bottom, re-attach
+			if (isAtBottom()) {
+				isDetached = false;
+			}
+
+			// Re-trigger scroll if still attached, to catch content that arrived during scrolling
+			if (!isDetached) {
+				scrollToBottom();
+			}
+		}, USER_SCROLL_DEBOUNCE_MS);
+	};
+
+	const createSentinel = () => {
+		sentinel = document.createElement("div");
+		sentinel.style.height = "1px";
+		sentinel.style.width = "100%";
+		sentinel.setAttribute("aria-hidden", "true");
+		sentinel.setAttribute("data-scroll-sentinel", "");
+
+		// Find the content container (first child) and append sentinel there
+		const container = node.firstElementChild;
+		if (container) {
+			container.appendChild(sentinel);
+		} else {
+			node.appendChild(sentinel);
+		}
+	};
+
+	const setupIntersectionObserver = () => {
+		if (typeof IntersectionObserver === "undefined" || !sentinel) return;
+
+		intersectionObserver = new IntersectionObserver(
+			(entries) => {
+				const entry = entries[0];
+
+				// If sentinel is visible and user isn't actively scrolling, we're at bottom
+				if (entry?.isIntersecting && !userScrolling) {
+					isDetached = false;
+					// Immediately scroll to catch up with any content that arrived while detached
+					scrollToBottom();
+				}
+			},
+			{
+				root: node,
+				threshold: 0,
+				rootMargin: `0px 0px ${BOTTOM_THRESHOLD}px 0px`,
+			}
+		);
+
+		intersectionObserver.observe(sentinel);
+	};
+
+	const setupResizeObserver = () => 
+
+--- src/lib/buildPrompt.ts ---
+import type { EndpointParameters } from "./server/endpoints/endpoints";
+import type { BackendModel } from "./server/models";
+
+type buildPromptOptions = Pick<EndpointParameters, "messages" | "preprompt"> & {
+	model: BackendModel;
+};
+
+export async function buildPrompt({
+	messages,
+	model,
+	preprompt,
+}: buildPromptOptions): Promise<string> {
+	const filteredMessages = messages;
+
+	if (filteredMessages[0].from === "system" && preprompt) {
+		filteredMessages[0].content = preprompt;
+	}
+
+	const prompt = model
+		.chatPromptRender({
+			messages: filteredMessages.map((m) => ({
+				...m,
+				role: m.from,
+			})),
+			preprompt,
+		})
+		// Not super precise, but it's truncated in the model's backend anyway
+		.split(" ")
+		.slice(-(model.parameters?.truncate ?? 0))
+		.join(" ");
+
+	return prompt;
+}
+
+
+--- src/lib/components/chat/MarkdownRenderer.svelte.test.ts ---
+import MarkdownRenderer from "./MarkdownRenderer.svelte";
+import { render } from "vitest-browser-svelte";
+import { page } from "@vitest/browser/context";
+
+import { describe, expect, it } from "vitest";
+
+describe("MarkdownRenderer", () => {
+	it("renders", () => {
+		render(MarkdownRenderer, { content: "Hello, world!" });
+		expect(page.getByText("Hello, world!")).toBeInTheDocument();
+	});
+	it("renders headings", () => {
+		render(MarkdownRenderer, { content: "# Hello, world!" });
+		expect(page.getByRole("heading", { level: 1 })).toBeInTheDocument();
+	});
+	it("renders links", () => {
+		render(MarkdownRenderer, { content: "[Hello, world!](https://example.com)" });
+		const link = page.getByRole("link", { name: "Hello, world!" });
+		expect(link).toBeInTheDocument();
+		expect(link).toHaveAttribute("href", "https://example.com");
+		expect(link).toHaveAttribute("target", "_blank");
+		expect(link).toHaveAttribute("rel", "noreferrer");
+	});
+	it("renders inline codespans", () => {
+		render(MarkdownRenderer, { content: "`foobar`" });
+		expect(page.getByRole("code")).toHaveTextContent("foobar");
+	});
+	it("renders block codes", () => {
+		render(MarkdownRenderer, { content: "```foobar```" });
+		expect(page.getByRole("code")).toHaveTextContent("foobar");
+	});
+	it("doesnt render raw html directly", () => {
+		render(MarkdownRenderer, { content: "<button>Click me</button>" });
+		expect(page.getByRole("button").elements).toHaveLength(0);
+		// htmlparser2 escapes disallowed tags
+		expect(page.getByRole("paragraph")).toHaveTextContent("<button>Click me</button>");
+	});
+	it("renders latex", () => {
+		const { baseElement } = render(MarkdownRenderer, { content: "$(oo)^2$" });
+		expect(baseElement.querySelectorAll(".katex")).toHaveLength(1);
+	});
+	it("does not render latex in code blocks", () => {
+		const { baseElement } = render(MarkdownRenderer, { content: "```\n$(oo)^2$\n```" });
+		expect(baseElement.querySelectorAll(".katex")).toHaveLength(0);
+	});
+	it("does not render latex in inline codes", () => {
+		const { baseElement } = render(MarkdownRenderer, { content: "`$oo` and `$bar`" });
+		expect(baseElement.querySelectorAll(".katex")).toHaveLength(0);
+	});
+	it("does not render latex across multiple lines", () => {
+		const { baseElement } = render(MarkdownRenderer, { content: "* $oo \n* $aa" });
+		expect(baseElement.querySelectorAll(".katex")).toHaveLength(0);
+	});
+	it("renders latex with some < and > symbols", () => {
+		const { baseElement } = render(MarkdownRenderer, { content: "$foo < bar > baz$" });
+		expect(baseElement.querySelectorAll(".katex")).toHaveLength(1);
+	});
+});
+
+
+--- src/lib/constants/mcpExamples.ts ---
+import type { RouterExample } from "./routerExamples";
+
+// Examples that showcase RuFlo MCP capabilities — agents, memory,
+// intelligence, dev tools, and the WASM gallery.
+export const mcpExamples: RouterExample[] = [
+	{
+		title: "Spawn a coding swarm",
+		prompt:
+			"Spawn a hierarchical swarm with 5 agents (architect, coder, tester, reviewer, security-auditor) to refactor a Python CLI tool to TypeScript. Use ruflo__swarm_init then ruflo__agent_spawn for each role.",
+		followUps: [
+			{
+				title: "Show progress",
+				prompt: "Use ruflo__progress_summary to show the swarm's current state.",
+			},
+			{
+				title: "Add tests",
+				prompt: "Spawn a tester agent to write integration tests for the swarm output.",
+			},
+		],
+	},
+	{
+		title: "Save & recall memory",
+		prompt:
+			"Use ruflo__memory_store to save: namespace='preferences', key='editor_theme', value='solarized-dark'. Then ruflo__memory_search query='theme' to verify.",
+		followUps: [
+			{
+				title: "List entries",
+				prompt: "List all entries in the 'preferences' namespace using ruflo__memory_list.",
+			},
+			{
+				title: "Semantic search",
+				prompt: "Find related memories with ruvector__hooks_recall query='editor settings'.",
+			},
+		],
+	},
+	{
+		title: "Route a task",
+		prompt:
+			"Use ruvector__hooks_route on the task: 'add OAuth2 to a SvelteKit API'. Tell me which agent type and topology you'd recommend.",
+		followUps: [
+			{
+				title: "Spawn the agent",
+				prompt: "Spawn the recommended agent with ruflo__agent_spawn.",
+			},
+			{
+				title: "Track trajectory",
+				prompt: "Begin a trajectory with ruvector__hooks_trajectory_begin to record the work.",
+			},
+		],
+	},
+	{
+		title: "Analyze a diff",
+		prompt:
+			"Use ruflo__analyze_diff to assess risk and ruflo__analyze_diff-reviewers to suggest reviewers for the PR at github.com/ruvnet/ruflo/pull/1687.",
+		followUps: [
+			{
+				title: "Repo metrics",
+				prompt: "Get repository metrics with ruflo__github_repo_analyze for ruvnet/ruflo.",
+			},
+			{
+				title: "Open issues",
+				prompt: "List recent issues with ruflo__github_issue_track for ruvnet/ruflo.",
+			},
+		],
+	},
+	{
+		title: "System health check",
+		prompt:
+			"Run ruflo__system_status, ruflo__performance_metrics, and ruflo__performance_bottleneck. Summarize anything concerning.",
+		followUps: [
+			{
+				title: "Optimize",
+				prompt: "Use ruflo__performance_optimize on the slowest component identified.",
+			},
+			{
+				title: "Benchmark",
+				prompt: "Run ruflo__performance_benchmark with --suite=all.",
+			},
+		],
+	},
+	{
+		title: "Browse WASM gallery",
+		prompt:
+			"Show me the templates in the WASM gallery (browser-side rvagent server) and explain what each one does.",
+		followUps: [
+			{
+				title: "Load a template",
+				prompt: "Load the most popular template into the local WASM MCP server.",
+			},
+		],
+	},
+	{
+		title: "Plan with GOAP",
+		prompt:
+			"Use the goal-planner pattern: I want to migrate a Postgres schema with zero downtime. Decompose into ruflo agents and tasks.",
+		followUps: [
+			{
+				title: "Risk analysis",
+				prompt: "Run ruflo__analyze_file-risk on the migration file.",
+			},
+		],
+	},
+	{
+		title: "Train neural pattern",
+		prompt:
+			"Use ruvector__neural_train to learn from this successful pattern: 'JWT auth with refresh tokens — store refresh in httpOnly cookie, access in memory'.",
+		followUps: [
+			{
+				title: "Predict",
+				prompt: "Use ruvector__neural_predict for the task 'add session-based auth'.",
+			},
+		],
+	},
+];
+
+
+--- src/lib/constants/mime.ts ---
+// Centralized MIME allowlists used across client and server
+// Keep these lists minimal and consistent with server processing.
+
+export const TEXT_MIME_ALLOWLIST = [
+	"text/*",
+	"application/json",
+	"application/xml",
+	"application/csv",
+] as const;
+
+export const IMAGE_MIME_ALLOWLIST_DEFAULT = ["image/jpeg", "image/png"] as const;
+
+
+--- src/lib/constants/pagination.ts ---
+export const CONV_NUM_PER_PAGE = 30;
+
+
+--- src/lib/constants/publicSepToken.ts ---
+export const PUBLIC_SEP_TOKEN = "</s>";
+
+
+--- src/lib/constants/routerExamples.ts ---
+export type RouterFollowUp = {
+	title: string;
+	prompt: string;
+};
+
+export type RouterExampleAttachment = {
+	src: string;
+};
+
+export type RouterExample = {
+	title: string;
+	prompt: string;
+	followUps?: RouterFollowUp[];
+	attachments?: RouterExampleAttachment[];
+};
+
+// RuFlo-themed router examples — shown on the empty-state welcome screen
+// when the user hasn't enabled the full MCP toolset. Keep these light enough
+// that even a model without tool-calling can answer (no explicit tool names).
+export const routerExamples: RouterExample[] = [
+	{
+		title: "Build a coding swarm",
+		prompt: "Design a 5-agent coding swarm to refactor a Python CLI to TypeScript. Suggest topology, roles, and the order each agent should run.",
+		followUps: [
+			{
+				title: "Add tests",
+				prompt: "Add a tester agent and a security-auditor. What should each one own?",
+			},
+			{
+				title: "Trade-offs",
+				prompt: "Compare hierarchical vs mesh topology for this swarm.",
+			},
+			{
+				title: "Failure mode",
+				prompt: "What happens if the architect agent fails halfway through?",
+			},
+		],
+	},
+	{
+		title: "Memory & recall",
+		prompt: "Explain how RuFlo's persistent memory works across sessions, and give me a 3-step example of saving a preference and recalling it later.",
+		followUps: [
+			{
+				title: "Namespaces",
+				prompt: "When should I use separate memory namespaces vs one shared namespace?",
+			},
+			{
+				title: "Vector vs key",
+				prompt: "When should I use semantic search vs exact key retrieval?",
+			},
+		],
+	},
+	{
+		title: "Plan a migration",
+		prompt: "Plan a zero-downtime Postgres schema migration. Use Goal-Oriented Action Planning to break it into phases with rollback points.",
+		followUps: [
+			{
+				title: "Risk scoring",
+				prompt: "Which phases are highest-risk and how would you mitigate them?",
+			},
+			{
+				title: "Verification",
+				prompt: "How would you verify each phase before proceeding?",
+			},
+		],
+	},
+	{
+		title: "Review a diff",
+		prompt: "What signals would you use to risk-score a code diff (size, files touched, hot paths) and how would you suggest reviewers?",
+		followUps: [
+			{
+				title: "Auto-classify",
+				prompt: "Classify a diff as feature/bugfix/refactor/docs from its file mix and message.",
+			},
+			{
+				title: "Security focus",
+				prompt: "Which patterns in a diff should trigger a security review?",
+			},
+		],
+	},
+	{
+		title: "Explain HNSW",
+		prompt: "Explain HNSW vector indexing in plain language, and why it's 150x-12,500x faster than brute-force similarity search at scale.",
+		followUps: [
+			{
+				title: "Quantization",
+				prompt: "What does Int8 quantization buy you, and what's the trade-off?",
+			},
+			{
+				title: "Use case",
+				prompt: "When would you reach for HNSW vs a relational keyword index?",
+			},
+		],
+	},
+	{
+		title: "Choose a topology",
+		prompt: "I have 12 agents to coordinate on a multi-step refactor. Compare hierarchical, mesh, hierarchical-mesh, and adaptive topologies — pick one and explain why.",
+		followUps: [
+			{
+				title: "Anti-drift",
+				prompt: "What's 'anti-drift' coordination and why does it matter for >8 agents?",
+			},
+			{
+				title: "Consensus",
+				prompt: "Compare Raft, Byzantine, gossip, and CRDT consensus for this swarm.",
+			},
+		],
+	},
+	{
+		title: "Track a long task",
+		prompt: "I'm starting a 4-week migration. How should I structure horizon tracking, milestone checkpoints, and drift detection in RuFlo?",
+		followUps: [
+			{
+				title: "Resume after break",
+				prompt: "What state should be persisted so I can resume next week?",
+			},
+		],
+	},
+	{
+		title: "Local WASM tools",
+		prompt: "What's the difference between the in-browser WASM MCP server and the cloud bridge MCP servers? When should I use each?",
+		followUps: [
+			{
+				title: "Privacy",
+				prompt: "Which tools never leave my browser?",
+			},
+			{
+				title: "Offline",
+				prompt: "What can RuFlo still do if my network drops?",
+			},
+		],
+	},
+];
+
+
+--- src/lib/constants/rvagentPresets.ts (truncated) ---
+/**
+ * rvAgent MCP Server Presets
+ *
+ * Pre-configured server configurations for the rvagent-mcp server
+ * with different tool group combinations. These presets correspond
+ * to the tool groups defined in ADR-112.
+ *
+ * Tool Groups:
+ * - file: read, write, edit, ls, glob, grep
+ * - shell: execute, bash
+ * - memory: semantic_search, store, retrieve
+ * - agent: spawn, status, orchestrate
+ * - git: status, commit, diff, log
+ * - web: fetch, search
+ * - brain: search, share, vote (π Brain)
+ * - task: create, list, complete
+ * - core: ping, initialize (always included)
+ */
+
+export interface RvAgentPreset {
+	/** Unique identifier for the preset */
+	id: string;
+	/** Display name */
+	name: string;
+	/** Short description */
+	description: string;
+	/** Tool groups to enable */
+	groups: string[];
+	/** Default port (user can override) */
+	defaultPort: number;
+	/** Icon/emoji for display */
+	icon: string;
+	/** Recommended use cases */
+	useCases: string[];
+}
+
+/**
+ * Pre-configured rvagent-mcp presets for common use cases
+ */
+export const RVAGENT_PRESETS: RvAgentPreset[] = [
+	{
+		id: "all-tools",
+		name: "All Tools",
+		description: "Full access to all 46+ rvAgent tools",
+		groups: ["all"],
+		defaultPort: 9000,
+		icon: "🔧",
+		useCases: ["Development", "Testing", "Full automation"],
+	},
+	{
+		id: "file-shell",
+		name: "File & Shell",
+		description: "File operations and command execution",
+		groups: ["file", "shell"],
+		defaultPort: 9001,
+		icon: "📂",
+		useCases: ["Code editing", "Build scripts", "File management"],
+	},
+	{
+		id: "memory-agent",
+		name: "Memory & Agent",
+		description: "Vector memory and multi-agent orchestration",
+		groups: ["memory", "agent"],
+		defaultPort: 9002,
+		icon: "🧠",
+		useCases: ["Knowledge retrieval", "Agent coordination", "RAG"],
+	},
+	{
+		id: "git-web",
+		name: "Git & Web",
+		description: "Version control and web operations",
+		groups: ["git", "web"],
+		defaultPort: 9003,
+		icon: "🌐",
+		useCases: ["Code review", "Research", "Documentation"],
+	},
+	{
+		id: "brain-task",
+		name: "Brain & Tasks",
+		description: "π Brain integration and task management",
+		groups: ["brain", "task"],
+		defaultPort: 9004,
+		icon: "🎯",
+		useCases: ["Knowledge sharing", "Task tracking", "Collaboration"],
+	},
+	{
+		id: "dev-minimal",
+		name: "Dev Minimal",
+		description: "Essential development tools only",
+		groups: ["file", "shell", "git"],
+		defaultPort: 9005,
+		icon: "💻",
+		useCases: ["Quick edits", "Simple scripts", "Git operations"],
+	},
+	{
+		id: "research",
+		name: "Research Mode",
+		description: "Memory, web search, and brain tools",
+		groups: ["memory", "web", "brain"],
+		defaultPort: 9006,
+		icon: "🔬",
+		useCases: ["Research", "Knowledge discovery", "Analysis"],
+	},
+	{
+		id: "orchestration",
+		name: "Orchestration",
+		description: "Agent spawning and task coordination",
+		groups: ["agent", "task", "memory"],
+		defaultPort: 9007,
+		icon: "🎭",
+		useCases: ["Multi-agent workflows", "Complex tasks", "Automation"],
+	},
+];
+
+/**
+ * Get preset by ID
+ */
+export function getPresetById(id: string): RvAgentPreset | undefined {
+	return RVAGENT_PRESETS.find((p) => p.id === id);
+}
+
+/**
+ * Build the SSE URL for a preset
+ */
+export function buildPresetUrl(preset: RvAgentPreset, host = "localhost", port?: number): string {
+	const actualPort = port ?? preset.defaultPort;
+	return `http://${host}:${actualPort}/sse`;
+}
+
+/**
+ * Build CLI command to start the server with preset configuration
+ */
+export function buildPresetCliCommand(preset: RvAgentPreset, port?: number): string {
+	const actualPort = port ?? preset.defaultPort;
+	const groupsArg = preset.groups.includes("all") ? "--all" : `--groups ${preset.groups.join(",")}`;
+
+	return `rvagent-mcp --transport sse --port ${actualPort} ${groupsArg}`;
+}
+
+/**
+ * Get all available tool group names
+ */
+export const TOOL_GROUPS = [
+	"file",
+	"shell",
+	"memory",
+	"agent",
+	"git",
+	"web",
+	"brain",
+	"task",
+	"core",
+] as const;
+
+export type ToolGroupName = (typeof TOOL_GROUPS)[number];
+
+/**
+ * Tool group descriptions for UI display
+ */
+export const TOOL_GROUP_INFO: Record<ToolGroupName, { name: string; tools: string[]; icon: string }> = {
+	file: {
+		name: "File Operations",
+		tools: ["read_file", "write_file", "edit_file", "ls", "glob", "grep"],
+		icon: "📁",
+	},
+	shell: {
+		name: "Shell Execution",
+		tools: ["execute", "bash"],
+		icon: "💻",
+	},
+	memory: {
+		name: "Vector Memory",
+		tools: ["semantic_search", "store_memory", "retrieve_memory"],
+		icon: "🧠",
+	},
+	agent: {
+		name: "Multi-Agent",
+		tools: ["spawn_agent", "agent_status", "orchestrate"],
+		icon: "🤖",
+	},
+	git: {
+		name: "Version Control",
+		tools: ["git_status", "git_commit", "git_diff", "git_log"],
+		icon: "📦",
+	},
+	web: {
+		name: "Web Operations",
+		tools: ["web_fetch", "web_search"],
+		icon: "🌐",
+	},
+	brain: {
+		name: "π Brain",
+		tools: ["brain_search", "brain_share", "brain_vote"],
+		icon: "🧪",
+	},
+	task: {
+		name: "Task Management",
+		tools: ["create_task", "list_tasks", "complete_task"],
+		icon: "✅",
+	},
+	core: {
+		n
+
+--- src/lib/createShareLink.ts ---
+import { base } from "$app/paths";
+import { page } from "$app/state";
+
+// Returns a public share URL for a conversation id.
+// If `id` is already a 7-char share id, no network call is made.
+export async function createShareLink(id: string): Promise<string> {
+	const prefix =
+		page.data.publicConfig.PUBLIC_SHARE_PREFIX ||
+		`${page.data.publicConfig.PUBLIC_ORIGIN || page.url.origin}${base}`;
+
+	if (id.length === 7) {
+		return `${prefix}/r/${id}`;
+	}
+
+	const res = await fetch(`${base}/conversation/${id}/share`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+	});
+
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new Error(text || "Failed to create share link");
+	}
+
+	const { shareId } = await res.json();
+	return `${prefix}/r/${shareId}`;
+}
+
+
+--- src/lib/jobs/refresh-conversation-stats.ts (truncated) ---
+import type { ConversationStats } from "$lib/types/ConversationStats";
+import { CONVERSATION_STATS_COLLECTION, collections } from "$lib/server/database";
+import { logger } from "$lib/server/logger";
+import type { ObjectId } from "mongodb";
+import { acquireLock, refreshLock } from "$lib/migrations/lock";
+import { Semaphores } from "$lib/types/Semaphore";
+
+async function getLastComputationTime(): Promise<Date> {
+	const lastStats = await collections.conversationStats.findOne({}, { sort: { "date.at": -1 } });
+	return lastStats?.date?.at || new Date(0);
+}
+
+async function shouldComputeStats(): Promise<boolean> {
+	const lastComputationTime = await getLastComputationTime();
+	const oneDayAgo = new Date(Date.now() - 24 * 3_600_000);
+	return lastComputationTime < oneDayAgo;
+}
+
+export async function computeAllStats() {
+	for (const span of ["day", "week", "month"] as const) {
+		computeStats({ dateField: "updatedAt", type: "conversation", span }).catch((e) =>
+			logger.error(e, "Error computing conversation stats for updatedAt")
+		);
+		computeStats({ dateField: "createdAt", type: "conversation", span }).catch((e) =>
+			logger.error(e, "Error computing conversation stats for createdAt")
+		);
+		computeStats({ dateField: "createdAt", type: "message", span }).catch((e) =>
+			logger.error(e, "Error computing message stats for createdAt")
+		);
+	}
+}
+
+async function computeStats(params: {
+	dateField: ConversationStats["date"]["field"];
+	span: ConversationStats["date"]["span"];
+	type: ConversationStats["type"];
+}) {
+	const indexes = await collections.semaphores.listIndexes().toArray();
+	if (indexes.length <= 2) {
+		logger.info("Indexes not created, skipping stats computation");
+		return;
+	}
+
+	const lastComputed = await collections.conversationStats.findOne(
+		{ "date.field": params.dateField, "date.span": params.span, type: params.type },
+		{ sort: { "date.at": -1 } }
+	);
+
+	// If the last computed week is at the beginning of the last computed month, we need to include some days from the previous month
+	// In those cases we need to compute the stats from before the last month as everything is one aggregation
+	const minDate = lastComputed ? lastComputed.date.at : new Date(0);
+
+	logger.debug(
+		{ minDate, dateField: params.dateField, span: params.span, type: params.type },
+		"Computing conversation stats"
+	);
+
+	const dateField = params.type === "message" ? "messages." + params.dateField : params.dateField;
+
+	const pipeline = [
+		{
+			$match: {
+				[dateField]: { $gte: minDate },
+			},
+		},
+		// For message stats: use $filter to reduce data before $unwind (optimization)
+		// For conversation stats: simple projection
+		...(params.type === "message"
+			? [
+					{
+						$project: {
+							// Filter messages by date, then map to only keep the date field
+							// This avoids carrying large message payloads (content, files, etc.) through the pipeline
+							messages: {
+								$map: {
+									input: {
+										$filter: {
+											input: "$messages",
+											as: "msg",
+											cond: { $gte: [`$$msg.${params.dateField}`, minDate] },
+										},
+									},
+									as: "msg",
+									in: { [params.dateField]: `$$msg.${params.dateField}` },
+								},
+							},
+							sessionId: 1,
+							userId: 1,
+						},
+					},
+					{
+						$unwind: "$messages",
+					},
+				]
+			: [
+					{
+						$project: {
+							[dateField]: 1,
+							sessionId: 1,
+							userId: 1,
+						},
+					},
+				]),
+		{
+			$sort: {
+				[dateField]: 1,
+			},
+		},
+		{
+			$facet: {
+				userId: [
+					{
+						$match: {
+							userId: { $exists: true },
+						},
+					},
+					{
+						$group: {
+							_id: {
+								at: { $dateTrunc: { date: `$${dateField}`, unit: params.span } },
+								userId: "$userId",
+							},
+						},
+					},
+					{
+						$group: {
+							_id: "$_id.at",
+							count: { $sum: 1 },
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+							date: {
+								at: "$_id",
+								field: params.dateField,
+								span: params.span,
+							},
+							distinct: "userId",
+							count: 1,
+						},
+					},
+				],
+				sessionId: [
+					{
+						$match: {
+							sessionId: { $exists: true },
+						},
+					},
+					{
+						$group: {
+							_id: {
+								at: { $dateTrunc: { date: `$${dateField}`, unit: params.span } },
+								sessionId: "$sessionId",
+							},
+						},
+					},
+					{
+						$group: {
+							_id: "$_id.at",
+							count: { $sum: 1 },
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+							date: {
+								at: "$_id",
+								field: params.dateField,
+								span: params.span,
+							},
+							distinct: "sessionId",
+							count: 1,
+						},
+					},
+				],
+				userOrSessionId: [
+					{
+						$group: {
+							_id: {
+								at: { $dateTrunc: { date: `$${dateField}`, unit: params.span } },
+								userOrSessionId: { $ifNull: ["$userId", "$sessionId"] },
+							},
+						},
+					},
+					{
+						$group: {
+							_id: "$_id.at",
+							count: { $sum: 1 },
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+							date: {
+								at: "$_id
+
+--- src/lib/migrations/lock.ts ---
+import { collections } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import type { Semaphores } from "$lib/types/Semaphore";
+
+/**
+ * Returns the lock id if the lock was acquired, false otherwise
+ */
+export async function acquireLock(key: Semaphores | string): Promise<ObjectId | false> {
+	try {
+		const id = new ObjectId();
+
+		const insert = await collections.semaphores.insertOne({
+			_id: id,
+			key,
+			createdAt: new Date(),
+			updatedAt: new Date(),
+			deleteAt: new Date(Date.now() + 1000 * 60 * 3), // 3 minutes
+		});
+
+		return insert.acknowledged ? id : false; // true if the document was inserted
+	} catch (e) {
+		// unique index violation, so there must already be a lock
+		return false;
+	}
+}
+
+export async function releaseLock(key: Semaphores | string, lockId: ObjectId) {
+	await collections.semaphores.deleteOne({
+		_id: lockId,
+		key,
+	});
+}
+
+export async function isDBLocked(key: Semaphores | string): Promise<boolean> {
+	const res = await collections.semaphores.countDocuments({
+		key,
+	});
+	return res > 0;
+}
+
+export async function refreshLock(key: Semaphores | string, lockId: ObjectId): Promise<boolean> {
+	const result = await collections.semaphores.updateOne(
+		{
+			_id: lockId,
+			key,
+		},
+		{
+			$set: {
+				updatedAt: new Date(),
+				deleteAt: new Date(Date.now() + 1000 * 60 * 3), // 3 minutes
+			},
+		}
+	);
+
+	return result.matchedCount > 0;
+}
+
+
+--- src/lib/migrations/migrations.spec.ts ---
+import { afterEach, assert, beforeAll, describe, expect, it } from "vitest";
+import { migrations } from "./routines";
+import { acquireLock, isDBLocked, refreshLock, releaseLock } from "./lock";
+import { Semaphores } from "$lib/types/Semaphore";
+import { collections, ready } from "$lib/server/database";
+
+describe(
+	"migrations",
+	{
+		retry: 3,
+	},
+	() => {
+		beforeAll(async () => {
+			await ready;
+			try {
+				await collections.semaphores.createIndex({ key: 1 }, { unique: true });
+			} catch (e) {
+				// Index might already exist, ignore error
+			}
+		}, 20000);
+
+		it("should not have duplicates guid", async () => {
+			const guids = migrations.map((m) => m._id.toString());
+			const uniqueGuids = [...new Set(guids)];
+			expect(uniqueGuids.length).toBe(guids.length);
+		});
+
+		it("should acquire only one lock on DB", async () => {
+			const results = await Promise.all(
+				new Array(1000).fill(0).map(() => acquireLock(Semaphores.TEST_MIGRATION))
+			);
+			const locks = results.filter((r) => r);
+
+			const semaphores = await collections.semaphores.find({}).toArray();
+
+			expect(locks.length).toBe(1);
+			expect(semaphores).toBeDefined();
+			expect(semaphores.length).toBe(1);
+			expect(semaphores?.[0].key).toBe(Semaphores.TEST_MIGRATION);
+		});
+
+		it("should read the lock correctly", async () => {
+			const lockId = await acquireLock(Semaphores.TEST_MIGRATION);
+			assert(lockId);
+			expect(await isDBLocked(Semaphores.TEST_MIGRATION)).toBe(true);
+			expect(!!(await acquireLock(Semaphores.TEST_MIGRATION))).toBe(false);
+			await releaseLock(Semaphores.TEST_MIGRATION, lockId);
+			expect(await isDBLocked(Semaphores.TEST_MIGRATION)).toBe(false);
+		});
+
+		it("should refresh the lock", async () => {
+			const lockId = await acquireLock(Semaphores.TEST_MIGRATION);
+
+			assert(lockId);
+
+			// get the updatedAt time
+
+			const updatedAtInitially = (await collections.semaphores.findOne({}))?.updatedAt;
+
+			await refreshLock(Semaphores.TEST_MIGRATION, lockId);
+
+			const updatedAtAfterRefresh = (await collections.semaphores.findOne({}))?.updatedAt;
+
+			expect(updatedAtInitially).toBeDefined();
+			expect(updatedAtAfterRefresh).toBeDefined();
+			expect(updatedAtInitially).not.toBe(updatedAtAfterRefresh);
+		});
+
+		afterEach(async () => {
+			await collections.semaphores.deleteMany({});
+			await collections.migrationResults.deleteMany({});
+		});
+	}
+);
+
+
+--- src/lib/migrations/migrations.ts ---
+import { Database } from "$lib/server/database";
+import { migrations } from "./routines";
+import { acquireLock, releaseLock, isDBLocked, refreshLock } from "./lock";
+import { Semaphores } from "$lib/types/Semaphore";
+import { logger } from "$lib/server/logger";
+import { config } from "$lib/server/config";
+
+export async function checkAndRunMigrations() {
+	// make sure all GUIDs are unique
+	if (new Set(migrations.map((m) => m._id.toString())).size !== migrations.length) {
+		throw new Error("Duplicate migration GUIDs found.");
+	}
+
+	// check if all migrations have already been run
+	const migrationResults = await (await Database.getInstance())
+		.getCollections()
+		.migrationResults.find()
+		.toArray();
+
+	logger.debug("[MIGRATIONS] Begin check...");
+
+	const lockId = await acquireLock(Semaphores.MIGRATION);
+
+	if (!lockId) {
+		// another instance already has the lock, so we exit early
+		logger.debug(
+			"[MIGRATIONS] Another instance already has the lock. Waiting for DB to be unlocked."
+		);
+
+		// block until the lock is released
+		while (await isDBLocked(Semaphores.MIGRATION)) {
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+		}
+		return;
+	}
+
+	// once here, we have the lock
+	// make sure to refresh it regularly while it's running
+	const refreshInterval = setInterval(async () => {
+		await refreshLock(Semaphores.MIGRATION, lockId);
+	}, 1000 * 10);
+
+	// iterate over all migrations
+	for (const migration of migrations) {
+		// check if the migration has already been applied
+		const shouldRun =
+			migration.runEveryTime ||
+			!migrationResults.find((m) => m._id.toString() === migration._id.toString());
+
+		// check if the migration has already been applied
+		if (!shouldRun) {
+			logger.debug(`[MIGRATIONS] "${migration.name}" already applied. Skipping...`);
+		} else {
+			// check the modifiers to see if some cases match
+			if (
+				(migration.runForHuggingChat === "only" && !config.isHuggingChat) ||
+				(migration.runForHuggingChat === "never" && config.isHuggingChat)
+			) {
+				logger.debug(
+					`[MIGRATIONS] "${migration.name}" should not be applied for this run. Skipping...`
+				);
+				continue;
+			}
+
+			// otherwise all is good and we can run the migration
+			logger.debug(
+				`[MIGRATIONS] "${migration.name}" ${
+					migration.runEveryTime ? "should run every time" : "not applied yet"
+				}. Applying...`
+			);
+
+			await (await Database.getInstance()).getCollections().migrationResults.updateOne(
+				{ _id: migration._id },
+				{
+					$set: {
+						name: migration.name,
+						status: "ongoing",
+					},
+				},
+				{ upsert: true }
+			);
+
+			let result = false;
+
+			try {
+				// RVF store: no transactions needed, run migration directly
+				result = await migration.up(await Database.getInstance());
+			} catch (e) {
+				logger.error(e, `[MIGRATIONS]  "${migration.name}" failed!`);
+			}
+
+			await (await Database.getInstance()).getCollections().migrationResults.updateOne(
+				{ _id: migration._id },
+				{
+					$set: {
+						name: migration.name,
+						status: result ? "success" : "failure",
+					},
+				},
+				{ upsert: true }
+			);
+		}
+	}
+
+	logger.debug("[MIGRATIONS] All migrations applied. Releasing lock");
+
+	clearInterval(refreshInterval);
+	await releaseLock(Semaphores.MIGRATION, lockId);
+}
+
+
+## Instructions
+
+Analyze the above codebase context and provide your response following the format specified in the task.