@bike4mind/cli 0.17.2 → 0.18.1

package/dist/{BackgroundAgentManager-DQjlUwRw.mjs → BackgroundAgentManager-BEPNKfmi.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { $ as ProjectEvents, $t as parseRateLimitHeaders, A as GenerateImageToolCallSchema, At as dayjsConfig_default, B as InviteEvents, Bt as obfuscateApiKey, C as ElabsEvents, Ct as UnauthorizedError, D as ForbiddenError, Dt as VideoModels, E as FileEvents, Et as VideoGenerationUsageTransaction, F as ImageEditUsageTransaction, Ft as isGPTImageModel, G as ModalEvents, Gt as settingsMap, H as KnowledgeType, Ht as resolveNavigationIntents, I as ImageGenerationUsageTransaction, It as isModelAccessible, J as OpenAIEmbeddingModel, K as ModelBackend, Kt as substituteArguments$1, L as ImageModels, Lt as isSupportedEmbeddingModel, M as GenericCreditDeductTransaction, Mt as getMcpProviderMetadata, N as HTTPError, Nt as getViewById, O as FriendshipEvents, Ot as XAI_IMAGE_MODELS, P as HttpStatus, Pt as isGPTImage2Model, Q as ProfileEvents, Qt as isNearLimit, R as InboxEvents, Rt as isZodError, S as DashboardParamsSchema, St as UiNavigationEvents, T as FeedbackEvents, Tt as VIDEO_SIZE_CONSTRAINTS, U as LLMEvents, Ut as sanitizeTelemetryError, V as InviteType, Vt as parseSkillArguments, W as MiscEvents, Wt as secureParameters, X as Permission, Xt as buildRateLimitLogEntry, Y as OpenAIImageGenerationInput, Z as PermissionDeniedError, Zt as extractSnippetMeta, _ as ChatCompletionCreateInputSchema, _t as TaskScheduleHandler, a as ALERT_THRESHOLDS, at as ReceivedCreditTransaction, b as CompletionApiUsageTransaction, bt as ToolUsageTransaction, c as ApiKeyScope, ct as ResearchModeParamsSchema, d as ArtifactTypeSchema, dt as ResearchTaskType, en as CollectionType, et as PromptIntentSchema, f as AuthEvents, ft as SessionEvents, gt as TagType, h as BadRequestError, ht as SupportedFabFileMimeTypes, it as RealtimeVoiceUsageTransaction, j as GenericCreditAddTransaction, jt as getAccessibleDataLakes, k as GEMINI_IMAGE_MODELS, kt as b4mLLMTools, l as ApiKeyType, lt as ResearchTaskExecutionType, m as BFL_SAFETY_TOLERANCE, mt as SubscriptionCreditTransaction, n as logger, nt as PurchaseTransaction, o as AiEvents, ot as RechartsChartTypeList, p as BFL_IMAGE_MODELS, pt as SpeechToTextUsageTransaction, q as NotFoundError, qt as toDataLakeConfig, rt as QuestMasterParamsSchema, s as ApiKeyEvents, st as RegInviteEvents, t as ConfigStore, tt as PromptMetaZodSchema, u as AppFileEvents, ut as ResearchTaskPeriodicFrequencyType, v as ChatModels, vt as TextGenerationUsageTransaction, w as FavoriteDocumentType, wt as UnprocessableEntityError, x as CorruptedFileError, xt as TransferCreditTransaction, y as ClaudeArtifactMimeTypes, yt as TooManyRequestsError, z as InternalServerError, zt as mapMimeTypeToArtifactType } from "./ConfigStore-7kcIJ-ux.mjs";
+import { $ as PermissionDeniedError, $t as extractSnippetMeta, A as FriendshipEvents, At as XAI_IMAGE_MODELS, B as InboxEvents, Bt as isZodError, C as CorruptedFileError, Ct as TransferCreditTransaction, D as FeedbackEvents, Dt as VIDEO_SIZE_CONSTRAINTS, E as FavoriteDocumentType, Et as UnprocessableEntityError, F as HTTPError, Ft as getViewById, G as LLMEvents, Gt as sanitizeTelemetryError, H as InviteEvents, Ht as obfuscateApiKey, I as HttpStatus, It as isGPTImage2Model, J as ModelBackend, Jt as substituteArguments$1, K as MiscEvents, Kt as secureParameters, L as ImageEditUsageTransaction, Lt as isGPTImageModel, M as GenerateImageToolCallSchema, Mt as dayjsConfig_default, N as GenericCreditAddTransaction, Nt as getAccessibleDataLakes, O as FileEvents, Ot as VideoGenerationUsageTransaction, P as GenericCreditDeductTransaction, Pt as getMcpProviderMetadata, Q as Permission, Qt as buildRateLimitLogEntry, R as ImageGenerationUsageTransaction, Rt as isModelAccessible, S as CompletionApiUsageTransaction, St as ToolUsageTransaction, T as ElabsEvents, Tt as UnauthorizedError, U as InviteType, Ut as parseSkillArguments, V as InternalServerError, Vt as mapMimeTypeToArtifactType, W as KnowledgeType, Wt as resolveNavigationIntents, X as OpenAIEmbeddingModel, Y as NotFoundError, Yt as toDataLakeConfig, Z as OpenAIImageGenerationInput, _ as BadRequestError, _t as SupportedFabFileMimeTypes, at as QuestMasterParamsSchema, b as ChatModels, bt as TextGenerationUsageTransaction, c as AiEvents, ct as RechartsChartTypeList, d as ApiKeyType, dt as ResearchTaskExecutionType, en as isNearLimit, et as ProfileEvents, f as AppFileEvents, ft as ResearchTaskPeriodicFrequencyType, g as BFL_SAFETY_TOLERANCE, gt as SubscriptionCreditTransaction, h as BFL_IMAGE_MODELS, ht as SpeechToTextUsageTransaction, it as PurchaseTransaction, j as GEMINI_IMAGE_MODELS, jt as b4mLLMTools, k as ForbiddenError, kt as VideoModels, l as ApiKeyEvents, lt as RegInviteEvents, m as AuthEvents, mt as SessionEvents, n as logger, nn as CollectionType, nt as PromptIntentSchema, ot as RealtimeVoiceUsageTransaction, p as ArtifactTypeSchema, pt as ResearchTaskType, q as ModalEvents, qt as settingsMap, rt as PromptMetaZodSchema, s as ALERT_THRESHOLDS, st as ReceivedCreditTransaction, t as ConfigStore, tn as parseRateLimitHeaders, tt as ProjectEvents, u as ApiKeyScope, ut as ResearchModeParamsSchema, vt as TagType, w as DashboardParamsSchema, wt as UiNavigationEvents, x as ClaudeArtifactMimeTypes, xt as TooManyRequestsError, y as ChatCompletionCreateInputSchema, yt as TaskScheduleHandler, z as ImageModels, zt as isSupportedEmbeddingModel } from "./ConfigStore-BbTg-UaE.mjs";
 import { a as isUserLockedOut, c as userCanDisableMFA, d as userRequiresMFA, f as verifyBackupCode, i as getLockoutTimeRemaining, l as userEligibleForMFA, n as generateBackupCodes, o as recordFailedAttempt, p as verifyTOTPToken, r as generateTOTPSetup, s as shouldResetFailedAttempts, t as clearFailedAttempts, u as userHasMFAConfigured } from "./utils-fqhJmuB8.mjs";
 import { n as isPathAllowed, t as assertPathAllowed } from "./pathValidation-D8tjkQXE-1HwvsuYT.mjs";
-import { t as version } from "./package-DLM23Ze7.mjs";
+import { t as version } from "./package-CSa_ad8r.mjs";
 import { execFile, execFileSync, spawn } from "child_process";
 import crypto, { createHash, randomBytes, randomUUID } from "crypto";
 import { existsSync, promises, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "fs";
@@ -8843,25 +8843,55 @@ function sanitizeJsonStringWithMeta(jsonStr, options) {
 }
 //#endregion
 //#region ../../b4m-core/quantum/dist/index.mjs
+/**
+* Scheduling's objective is makespan (lower is better), rendered in time units.
+* This is the `ObjectiveMeta` every scheduling `SolverResult` carries so that
+* shared, family-agnostic UI can render scheduling results too.
+*/
+const SCHEDULING_OBJECTIVE_META = {
+	label: "makespan",
+	unit: "t",
+	direction: "min",
+	format: { suffix: "t" }
+};
+/**
+* Build a scheduling `SolverResult` from the domain-native quantities a solver
+* produces (a schedule + its makespan), filling in the shared-contract fields.
+* Keeps the makespan→objective mapping in one place across all 11 solvers.
+*/
+function makeSchedulingResult(args) {
+	return {
+		solverId: args.solverId,
+		solverName: args.solverName,
+		objective: args.makespan,
+		internalCost: args.makespan,
+		objectiveMeta: SCHEDULING_OBJECTIVE_META,
+		solution: args.schedule,
+		elapsedMs: args.elapsedMs,
+		iterations: args.iterations,
+		trace: args.trace,
+		metadata: args.metadata
+	};
+}
 const OperationSchema = z.object({
 	jobId: z.number(),
 	machineId: z.number(),
-	duration: z.number().positive()
+	duration: z.number().positive().max(1e6)
 });
 const JobSchema = z.object({
 	id: z.number(),
-	name: z.string(),
-	operations: z.array(OperationSchema)
+	name: z.string().max(200),
+	operations: z.array(OperationSchema).max(1e3)
 });
 const MachineSchema = z.object({
 	id: z.number(),
-	name: z.string()
+	name: z.string().max(200)
 });
 const SchedulingProblemSchema = z.object({
-	name: z.string(),
-	description: z.string().optional(),
-	jobs: z.array(JobSchema),
-	machines: z.array(MachineSchema),
+	name: z.string().max(200),
+	description: z.string().max(2e3).optional(),
+	jobs: z.array(JobSchema).max(1e3),
+	machines: z.array(MachineSchema).max(1e3),
 	solvedJobUrl: z.string().url().optional()
 });
 const SolverIdSchema = z.enum([
@@ -8920,19 +8950,24 @@ const greedySolver = {
 			if (options?.onProgress) options.onProgress({
 				solverId: "greedy",
 				percentage: Math.round(opsScheduled / totalOps * 100),
-				bestMakespan: opEnd,
+				bestObjective: opEnd,
 				currentIteration: opsScheduled,
 				totalIterations: totalOps
 			});
 		}
-		return {
+		const makespan = Math.max(...schedule.map((op) => op.endTime));
+		return makeSchedulingResult({
 			solverId: "greedy",
 			solverName: "Greedy (Earliest Start)",
-			makespan: Math.max(...schedule.map((op) => op.endTime)),
+			makespan,
 			schedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: totalOps
-		};
+			iterations: totalOps,
+			trace: [{
+				solution: schedule,
+				objective: makespan
+			}]
+		});
 	}
 };
 /**
@@ -9062,6 +9097,34 @@ function validateScheduleFeasibility(schedule) {
 	return true;
 }
 /**
+* Append a best-so-far snapshot, thinning the early history when over cap so the
+* trace stays bounded while preserving the first point and recent progress.
+* (Same thinning policy as the family engine's pushTrace.)
+*/
+function pushScheduleTrace(trace, schedule, makespan) {
+	trace.push({
+		solution: schedule,
+		objective: makespan
+	});
+	if (trace.length > 48) {
+		const first = trace[0];
+		const rest = trace.slice(1).filter((_, i) => i % 2 === 1);
+		trace.length = 0;
+		trace.push(first, ...rest);
+	}
+}
+const nowMs = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+/**
+* Combine the timeoutMs budget with cooperative cancellation into one stop check
+* that iterative solvers poll between moves — so a UI cancel or a timeout actually
+* halts a long run instead of being decorative. `defaultTimeoutMs` preserves each
+* solver's historical default when the caller omits timeoutMs.
+*/
+function makeScheduleStopper(options, startTime, defaultTimeoutMs) {
+	const deadline = startTime + (options?.timeoutMs ?? defaultTimeoutMs);
+	return () => (options?.shouldCancel?.() ?? false) || nowMs() > deadline;
+}
+/**
 * Simple seeded pseudo-random number generator (mulberry32).
 */
 function createRng$1(seed) {
@@ -9097,25 +9160,31 @@ const naiveSolver = {
 	description: "Evaluates all permutations to find the optimal schedule. Only feasible for small problems.",
 	async solve(problem, options) {
 		const startTime = performance.now();
+		const stop = makeScheduleStopper(options, startTime, 15e3);
 		const ops = buildOperationList(problem);
 		const totalPerms = factorial(ops.length);
 		const cappedTotal = Math.min(totalPerms, MAX_PERMUTATIONS);
-		let bestMakespan = Infinity;
 		let bestSchedule = decodePermutation(ops, problem);
+		let bestMakespan = computeMakespan(bestSchedule);
 		let count = 0;
+		const trace = [{
+			solution: bestSchedule,
+			objective: bestMakespan
+		}];
 		for (const perm of permutations(ops)) {
-			if (count >= MAX_PERMUTATIONS) break;
+			if (count >= MAX_PERMUTATIONS || stop()) break;
 			const schedule = decodePermutation(perm, problem);
 			const makespan = computeMakespan(schedule);
 			if (makespan < bestMakespan) {
 				bestMakespan = makespan;
 				bestSchedule = schedule;
+				pushScheduleTrace(trace, bestSchedule, bestMakespan);
 			}
 			count++;
 			if (options?.onProgress && count % 100 === 0) options.onProgress({
 				solverId: "naive",
 				percentage: Math.min(99, Math.round(count / cappedTotal * 100)),
-				bestMakespan,
+				bestObjective: bestMakespan,
 				currentIteration: count,
 				totalIterations: cappedTotal
 			});
@@ -9123,18 +9192,19 @@ const naiveSolver = {
 		options?.onProgress?.({
 			solverId: "naive",
 			percentage: 100,
-			bestMakespan,
+			bestObjective: bestMakespan,
 			currentIteration: count,
 			totalIterations: cappedTotal
 		});
-		return {
+		return makeSchedulingResult({
 			solverId: "naive",
 			solverName: "Naive (Brute Force)",
 			makespan: bestMakespan,
 			schedule: bestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: count
-		};
+			iterations: count,
+			trace
+		});
 	}
 };
 function factorial(n) {
@@ -9158,18 +9228,22 @@ const randomRestartSolver = {
 	description: "Multiple random starts with local search improvement via operation swaps.",
 	async solve(problem, options) {
 		const startTime = performance.now();
-		const timeoutMs = options?.timeoutMs ?? 1e4;
+		const stop = makeScheduleStopper(options, startTime, 1e4);
 		const rng = createRng$1(42);
-		let globalBestMakespan = Infinity;
 		let globalBestSchedule = decodePermutation(randomPermutation(problem, rng), problem);
+		let globalBestMakespan = computeMakespan(globalBestSchedule);
 		let totalIterations = 0;
+		const trace = [{
+			solution: globalBestSchedule,
+			objective: globalBestMakespan
+		}];
 		for (let restart = 0; restart < RESTARTS; restart++) {
-			if (performance.now() - startTime > timeoutMs) break;
+			if (stop()) break;
 			let currentPerm = randomPermutation(problem, rng);
 			let currentSchedule = decodePermutation(currentPerm, problem);
 			let currentMakespan = computeMakespan(currentSchedule);
 			for (let i = 0; i < HILL_CLIMB_ITERATIONS; i++) {
-				if (performance.now() - startTime > timeoutMs) break;
+				if (stop()) break;
 				const neighborPerm = swapNeighbor(currentPerm, rng);
 				const neighborSchedule = decodePermutation(neighborPerm, problem);
 				const neighborMakespan = computeMakespan(neighborSchedule);
@@ -9183,23 +9257,25 @@ const randomRestartSolver = {
 			if (currentMakespan < globalBestMakespan) {
 				globalBestMakespan = currentMakespan;
 				globalBestSchedule = currentSchedule;
+				pushScheduleTrace(trace, globalBestSchedule, globalBestMakespan);
 			}
 			options?.onProgress?.({
 				solverId: "random-restart",
 				percentage: Math.round((restart + 1) / RESTARTS * 100),
-				bestMakespan: globalBestMakespan,
+				bestObjective: globalBestMakespan,
 				currentIteration: restart + 1,
 				totalIterations: RESTARTS
 			});
 		}
-		return {
+		return makeSchedulingResult({
 			solverId: "random-restart",
 			solverName: "Random Restart Hill Climbing",
 			makespan: globalBestMakespan,
 			schedule: globalBestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: totalIterations
-		};
+			iterations: totalIterations,
+			trace
+		});
 	}
 };
 const SA_CONFIGS = [
@@ -9235,17 +9311,21 @@ function createSASolver(config) {
 		description: config.description,
 		async solve(problem, options) {
 			const startTime = performance.now();
-			const timeoutMs = options?.timeoutMs ?? 3e4;
+			const stop = makeScheduleStopper(options, startTime, 3e4);
 			const rng = createRng$1(42);
 			let currentPerm = randomPermutation(problem, rng);
 			let currentSchedule = decodePermutation(currentPerm, problem);
 			let currentMakespan = computeMakespan(currentSchedule);
 			let bestSchedule = currentSchedule;
 			let bestMakespan = currentMakespan;
+			const trace = [{
+				solution: bestSchedule,
+				objective: bestMakespan
+			}];
 			let temperature = config.initialTemp;
 			const progressInterval = Math.max(1, Math.floor(config.iterations / 100));
 			for (let i = 0; i < config.iterations; i++) {
-				if (performance.now() - startTime > timeoutMs) break;
+				if (stop()) break;
 				const neighborPerm = swapNeighbor(currentPerm, rng);
 				const neighborSchedule = decodePermutation(neighborPerm, problem);
 				const neighborMakespan = computeMakespan(neighborSchedule);
@@ -9257,13 +9337,14 @@ function createSASolver(config) {
 					if (currentMakespan < bestMakespan) {
 						bestSchedule = currentSchedule;
 						bestMakespan = currentMakespan;
+						pushScheduleTrace(trace, bestSchedule, bestMakespan);
 					}
 				}
 				temperature *= config.coolingRate;
 				if (options?.onProgress && i % progressInterval === 0) options.onProgress({
 					solverId: config.id,
 					percentage: Math.round(i / config.iterations * 100),
-					bestMakespan,
+					bestObjective: bestMakespan,
 					currentIteration: i,
 					totalIterations: config.iterations
 				});
@@ -9271,18 +9352,19 @@ function createSASolver(config) {
 			options?.onProgress?.({
 				solverId: config.id,
 				percentage: 100,
-				bestMakespan,
+				bestObjective: bestMakespan,
 				currentIteration: config.iterations,
 				totalIterations: config.iterations
 			});
-			return {
+			return makeSchedulingResult({
 				solverId: config.id,
 				solverName: config.name,
 				makespan: bestMakespan,
 				schedule: bestSchedule,
 				elapsedMs: performance.now() - startTime,
-				iterations: config.iterations
-			};
+				iterations: config.iterations,
+				trace
+			});
 		}
 	};
 }
@@ -9296,7 +9378,7 @@ const simulatedAnnealingLargeSolver = createSASolver(SA_CONFIGS[2]);
 * forbidden for a period. This prevents cycling and forces exploration
 * of new regions of the solution space.
 */
-const ITERATIONS$1 = 1e4;
+const ITERATIONS$2 = 1e4;
 const TABU_TENURE = 15;
 const NEIGHBORHOOD_SIZE = 20;
 const tabuSolver = {
@@ -9305,17 +9387,21 @@ const tabuSolver = {
 	description: "Hill climbing with short-term memory to avoid revisiting recent solutions.",
 	async solve(problem, options) {
 		const startTime = performance.now();
-		const timeoutMs = options?.timeoutMs ?? 15e3;
+		const stop = makeScheduleStopper(options, startTime, 15e3);
 		const rng = createRng$1(42);
 		let currentPerm = randomPermutation(problem, rng);
 		let currentSchedule = decodePermutation(currentPerm, problem);
 		let currentMakespan = computeMakespan(currentSchedule);
 		let bestSchedule = currentSchedule;
 		let bestMakespan = currentMakespan;
+		const trace = [{
+			solution: bestSchedule,
+			objective: bestMakespan
+		}];
 		const tabuList = /* @__PURE__ */ new Map();
-		const progressInterval = Math.max(1, Math.floor(ITERATIONS$1 / 100));
-		for (let iter = 0; iter < ITERATIONS$1; iter++) {
-			if (performance.now() - startTime > timeoutMs) break;
+		const progressInterval = Math.max(1, Math.floor(ITERATIONS$2 / 100));
+		for (let iter = 0; iter < ITERATIONS$2; iter++) {
+			if (stop()) break;
 			let bestNeighborPerm = null;
 			let bestNeighborMakespan = Infinity;
 			let bestSwapKey = "";
@@ -9341,6 +9427,7 @@ const tabuSolver = {
 				if (currentMakespan < bestMakespan) {
 					bestMakespan = currentMakespan;
 					bestSchedule = currentSchedule;
+					pushScheduleTrace(trace, bestSchedule, bestMakespan);
 				}
 			}
 			if (iter % 100 === 0) {
@@ -9348,27 +9435,28 @@ const tabuSolver = {
 			}
 			if (options?.onProgress && iter % progressInterval === 0) options.onProgress({
 				solverId: "tabu",
-				percentage: Math.round(iter / ITERATIONS$1 * 100),
-				bestMakespan,
+				percentage: Math.round(iter / ITERATIONS$2 * 100),
+				bestObjective: bestMakespan,
 				currentIteration: iter,
-				totalIterations: ITERATIONS$1
+				totalIterations: ITERATIONS$2
 			});
 		}
 		options?.onProgress?.({
 			solverId: "tabu",
 			percentage: 100,
-			bestMakespan,
-			currentIteration: ITERATIONS$1,
-			totalIterations: ITERATIONS$1
+			bestObjective: bestMakespan,
+			currentIteration: ITERATIONS$2,
+			totalIterations: ITERATIONS$2
 		});
-		return {
+		return makeSchedulingResult({
 			solverId: "tabu",
 			solverName: "Tabu Search",
 			makespan: bestMakespan,
 			schedule: bestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: ITERATIONS$1
-		};
+			iterations: ITERATIONS$2,
+			trace
+		});
 	}
 };
 /**
@@ -9387,7 +9475,7 @@ const geneticAlgorithmSolver = {
 	description: "Population-based search with tournament selection, crossover, and mutation.",
 	async solve(problem, options) {
 		const startTime = performance.now();
-		const timeoutMs = options?.timeoutMs ?? 2e4;
+		const stop = makeScheduleStopper(options, startTime, 2e4);
 		const rng = createRng$1(42);
 		let population = [];
 		for (let i = 0; i < POPULATION_SIZE; i++) {
@@ -9399,8 +9487,12 @@ const geneticAlgorithmSolver = {
 			});
 		}
 		let bestIndividual = population.reduce((best, ind) => ind.makespan < best.makespan ? ind : best);
+		const trace = [{
+			solution: decodePermutation(bestIndividual.perm, problem),
+			objective: bestIndividual.makespan
+		}];
 		for (let gen = 0; gen < GENERATIONS; gen++) {
-			if (performance.now() - startTime > timeoutMs) break;
+			if (stop()) break;
 			const newPopulation = [];
 			newPopulation.push({ ...bestIndividual });
 			while (newPopulation.length < POPULATION_SIZE) {
@@ -9416,24 +9508,28 @@ const geneticAlgorithmSolver = {
 			}
 			population = newPopulation;
 			const genBest = population.reduce((best, ind) => ind.makespan < best.makespan ? ind : best);
-			if (genBest.makespan < bestIndividual.makespan) bestIndividual = genBest;
+			if (genBest.makespan < bestIndividual.makespan) {
+				bestIndividual = genBest;
+				pushScheduleTrace(trace, decodePermutation(bestIndividual.perm, problem), bestIndividual.makespan);
+			}
 			options?.onProgress?.({
 				solverId: "genetic-algorithm",
 				percentage: Math.round((gen + 1) / GENERATIONS * 100),
-				bestMakespan: bestIndividual.makespan,
+				bestObjective: bestIndividual.makespan,
 				currentIteration: gen + 1,
 				totalIterations: GENERATIONS
 			});
 		}
 		const bestSchedule = decodePermutation(bestIndividual.perm, problem);
-		return {
+		return makeSchedulingResult({
 			solverId: "genetic-algorithm",
 			solverName: "Genetic Algorithm",
 			makespan: bestIndividual.makespan,
 			schedule: bestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: GENERATIONS * POPULATION_SIZE
-		};
+			iterations: GENERATIONS * POPULATION_SIZE,
+			trace
+		});
 	}
 };
 function tournamentSelect(population, size, rng) {
@@ -9477,10 +9573,10 @@ function crossover(parent1, parent2, rng) {
 * assignments) that appear in good solutions and evaporate over time.
 */
 const NUM_ANTS = 20;
-const ITERATIONS = 100;
+const ITERATIONS$1 = 100;
 const ALPHA = 1;
 const BETA = 2;
-const EVAPORATION = .1;
+const EVAPORATION$1 = .1;
 const Q = 100;
 const antColonySolver = {
 	id: "ant-colony",
@@ -9488,7 +9584,7 @@ const antColonySolver = {
 	description: "Swarm intelligence using pheromone trails to guide solution construction.",
 	async solve(problem, options) {
 		const startTime = performance.now();
-		const timeoutMs = options?.timeoutMs ?? 2e4;
+		const stop = makeScheduleStopper(options, startTime, 2e4);
 		const rng = createRng$1(42);
 		const allOps = buildOperationList(problem);
 		const numOps = allOps.length;
@@ -9496,10 +9592,14 @@ const antColonySolver = {
 		const heuristic = allOps.map((ref) => {
 			return 1 / problem.jobs.find((j) => j.id === ref.jobId).operations[ref.opIndex].duration;
 		});
-		let bestMakespan = Infinity;
 		let bestSchedule = decodePermutation(allOps, problem);
-		for (let iter = 0; iter < ITERATIONS; iter++) {
-			if (performance.now() - startTime > timeoutMs) break;
+		let bestMakespan = computeMakespan(bestSchedule);
+		const trace = [{
+			solution: bestSchedule,
+			objective: bestMakespan
+		}];
+		for (let iter = 0; iter < ITERATIONS$1; iter++) {
+			if (stop()) break;
 			const antSolutions = [];
 			for (let ant = 0; ant < NUM_ANTS; ant++) {
 				const perm = constructSolution(allOps, pheromone, heuristic, rng);
@@ -9512,9 +9612,10 @@ const antColonySolver = {
 				if (makespan < bestMakespan) {
 					bestMakespan = makespan;
 					bestSchedule = schedule;
+					pushScheduleTrace(trace, bestSchedule, bestMakespan);
 				}
 			}
-			for (let i = 0; i < numOps; i++) for (let j = 0; j < numOps; j++) pheromone[i][j] *= 1 - EVAPORATION;
+			for (let i = 0; i < numOps; i++) for (let j = 0; j < numOps; j++) pheromone[i][j] *= 1 - EVAPORATION$1;
 			for (const solution of antSolutions) {
 				const deposit = Q / solution.makespan;
 				for (let pos = 0; pos < solution.perm.length; pos++) {
@@ -9524,20 +9625,21 @@ const antColonySolver = {
 			}
 			options?.onProgress?.({
 				solverId: "ant-colony",
-				percentage: Math.round((iter + 1) / ITERATIONS * 100),
-				bestMakespan,
+				percentage: Math.round((iter + 1) / ITERATIONS$1 * 100),
+				bestObjective: bestMakespan,
 				currentIteration: iter + 1,
-				totalIterations: ITERATIONS
+				totalIterations: ITERATIONS$1
 			});
 		}
-		return {
+		return makeSchedulingResult({
 			solverId: "ant-colony",
 			solverName: "Ant Colony Optimization",
 			makespan: bestMakespan,
 			schedule: bestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: ITERATIONS * NUM_ANTS
-		};
+			iterations: ITERATIONS$1 * NUM_ANTS,
+			trace
+		});
 	}
 };
 /**
@@ -9783,23 +9885,18 @@ function validateSchedule(problem, schedule) {
 		errors
 	};
 }
-const MAX_BINARY_VARS = 150;
-const MAX_TOTAL_OPS = 80;
-const MAX_OPS_PER_MACHINE = 8;
-/**
-* Load HiGHS - creates FRESH instance each time.
-*
-* We intentionally do NOT cache the HiGHS instance.
-* Caching causes WASM corruption errors.
-*/
+/** Load a fresh HiGHS WASM instance (never cache it — see file header). */
 async function loadHiGHS() {
 	const highsLoader = (await import("highs")).default;
-	return await highsLoader({ locateFile: (file) => {
+	return highsLoader({ locateFile: (file) => {
 		const globalSelf = globalThis;
 		if (globalSelf.location?.origin) return `${globalSelf.location.origin}/${file}`;
 		return file;
 	} });
 }
+const MAX_BINARY_VARS = 150;
+const MAX_TOTAL_OPS = 80;
+const MAX_OPS_PER_MACHINE = 8;
 function elapsed(startTime) {
 	return typeof performance !== "undefined" ? performance.now() - startTime : Date.now() - startTime;
 }
@@ -9813,7 +9910,7 @@ const highsSolver = {
 			options?.onProgress?.({
 				solverId: "highs",
 				percentage,
-				bestMakespan
+				bestObjective: bestMakespan
 			});
 		};
 		reportProgress(0);
@@ -9831,6 +9928,21 @@ const highsSolver = {
 			const lpString = generateLPFormulation(problem);
 			if (!lpString.includes("Subject To") || !lpString.includes("Bounds")) throw new Error("Invalid LP formulation - missing required sections");
 			reportProgress(20);
+			if (options?.shouldCancel?.()) {
+				const g = await greedySolver.solve(problem, {});
+				return makeSchedulingResult({
+					solverId: "highs",
+					solverName: "HiGHS (WASM)",
+					makespan: g.objective,
+					schedule: g.solution,
+					elapsedMs: elapsed(startTime),
+					iterations: 0,
+					metadata: {
+						usedFallback: true,
+						reason: "cancelled before HiGHS solve"
+					}
+				});
+			}
 			let solution;
 			try {
 				solution = highs.solve(lpString, {
@@ -9863,14 +9975,18 @@ const highsSolver = {
 				throw new Error(`[HiGHS] Solution validation failed: ${errorDetails}`);
 			}
 			reportProgress(100, makespan);
-			return {
+			return makeSchedulingResult({
 				solverId: "highs",
 				solverName: "HiGHS (WASM)",
 				makespan,
 				schedule,
 				elapsedMs: elapsed(startTime),
-				iterations: 1
-			};
+				iterations: 1,
+				trace: [{
+					solution: schedule,
+					objective: makespan
+				}]
+			});
 		} catch (error) {
 			reportProgress(0);
 			throw error;
@@ -10514,30 +10630,39 @@ const allSolvers = [
 				solverId: "qaoa-local",
 				percentage: pct
 			});
+			const cancelled = () => options.shouldCancel?.() ?? false;
 			progress(0);
 			const greedyResult = await greedySolver.solve(problem, {});
 			progress(10);
-			const maxTime = greedyResult.makespan;
-			const encoded = encodeSchedulingWithMetadata(problem, maxTime);
+			const greedyMakespan = greedyResult.objective;
+			const greedySchedule = greedyResult.solution;
+			const greedyFallback = (reason) => makeSchedulingResult({
+				solverId: "qaoa-local",
+				solverName: "QAOA (Local)",
+				makespan: greedyMakespan,
+				schedule: greedySchedule,
+				elapsedMs: elapsed(),
+				trace: [{
+					solution: greedySchedule,
+					objective: greedyMakespan
+				}],
+				metadata: {
+					layers: LAYERS$1,
+					shots: 0,
+					gamma: 0,
+					beta: 0,
+					rawMakespan: greedyMakespan,
+					usedFallback: true,
+					reason
+				}
+			});
+			const encoded = encodeSchedulingWithMetadata(problem, greedyMakespan);
 			const numQubits = encoded.qubo.size;
 			if (numQubits > MAX_QUBITS || numQubits === 0) {
 				progress(100);
-				return {
-					solverId: "qaoa-local",
-					solverName: "QAOA (Local)",
-					makespan: greedyResult.makespan,
-					schedule: greedyResult.schedule,
-					elapsedMs: elapsed(),
-					metadata: {
-						layers: LAYERS$1,
-						shots: 0,
-						gamma: 0,
-						beta: 0,
-						rawMakespan: greedyResult.makespan,
-						usedFallback: true
-					}
-				};
+				return greedyFallback(numQubits === 0 ? "no qubits to encode" : `instance needs ${numQubits} qubits (cap ${MAX_QUBITS})`);
 			}
+			if (cancelled()) return greedyFallback("cancelled");
 			const ising = quboToIsing(encoded.qubo);
 			const backend = new LocalSimBackend();
 			progress(20);
@@ -10547,30 +10672,39 @@ const allSolvers = [
 				p: LAYERS$1
 			});
 			progress(75);
+			if (cancelled()) return greedyFallback("cancelled");
 			const gates = buildQAOACircuit(numQubits, ising, [gamma], [beta], LAYERS$1);
 			const { probabilities } = await backend.run(numQubits, gates);
 			const samples = sampleFromProbabilities(probabilities, FINAL_SHOTS$1);
 			progress(90);
-			const candidates = [decodeFromArgmax(problem, encoded.variables, probabilities, greedyResult.schedule), decodeSamples(problem, encoded.variables, samples)].filter((d) => d !== null);
+			const candidates = [decodeFromArgmax(problem, encoded.variables, probabilities, greedySchedule), decodeSamples(problem, encoded.variables, samples)].filter((d) => d !== null);
 			const bestQuantum = candidates.length > 0 ? candidates.reduce((a, b) => b.makespan < a.makespan ? b : a) : null;
-			const usedFallback = bestQuantum === null || bestQuantum.makespan >= greedyResult.makespan;
-			const winner = usedFallback ? greedyResult : bestQuantum;
+			const usedFallback = bestQuantum === null || bestQuantum.makespan >= greedyMakespan;
+			const winnerMakespan = usedFallback ? greedyMakespan : bestQuantum.makespan;
+			const winnerSchedule = usedFallback ? greedySchedule : bestQuantum.schedule;
 			progress(100);
-			return {
+			return makeSchedulingResult({
 				solverId: "qaoa-local",
 				solverName: "QAOA (Local)",
-				makespan: winner.makespan,
-				schedule: winner.schedule,
+				makespan: winnerMakespan,
+				schedule: winnerSchedule,
 				elapsedMs: elapsed(),
+				trace: [{
+					solution: greedySchedule,
+					objective: greedyMakespan
+				}, {
+					solution: winnerSchedule,
+					objective: winnerMakespan
+				}],
 				metadata: {
 					layers: LAYERS$1,
 					shots: FINAL_SHOTS$1,
 					gamma,
 					beta,
-					rawMakespan: bestQuantum?.makespan ?? greedyResult.makespan,
+					rawMakespan: bestQuantum?.makespan ?? greedyMakespan,
 					usedFallback
 				}
-			};
+			});
 		}
 	}
 ];
@@ -10869,54 +11003,1966 @@ No markdown, no explanation, no code blocks — just the raw JSON object.`;
 	"            \\/  <- fit here",
 	"Minimize: sum(error^2)"
 ].join("\n");
-/** Build a jittered grid mesh: cells at (col,row), edges between face-sharing neighbors. */
-function gridMesh(cols, rows, cellName, weightAt, jitter) {
-	const nodes = [];
-	const padX = 100 / (cols + 1);
-	const padY = 100 / (rows + 1);
-	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
-		const i = r * cols + c;
-		const { dx, dy } = jitter(i);
-		nodes.push({
-			id: i,
-			name: cellName(i),
-			x: Math.round(padX * (c + 1) + dx),
-			y: Math.round(padY * (r + 1) + dy)
-		});
+const routingSampleProblems = [
+	{
+		family: "routing",
+		name: "Austin Food Truck Circuit",
+		description: "A food truck owner wants the shortest nightly loop hitting ten Austin hotspots, starting and ending at the South Lamar commissary.",
+		nodes: [
+			{
+				id: 0,
+				name: "Commissary (S Lamar)",
+				x: 38,
+				y: 72
+			},
+			{
+				id: 1,
+				name: "Zilker Park",
+				x: 30,
+				y: 58
+			},
+			{
+				id: 2,
+				name: "Rainey St",
+				x: 56,
+				y: 60
+			},
+			{
+				id: 3,
+				name: "6th & Red River",
+				x: 54,
+				y: 48
+			},
+			{
+				id: 4,
+				name: "UT Campus",
+				x: 52,
+				y: 32
+			},
+			{
+				id: 5,
+				name: "Mueller Market",
+				x: 72,
+				y: 30
+			},
+			{
+				id: 6,
+				name: "East Cesar Chavez",
+				x: 70,
+				y: 56
+			},
+			{
+				id: 7,
+				name: "Barton Springs",
+				x: 34,
+				y: 64
+			},
+			{
+				id: 8,
+				name: "The Domain",
+				x: 44,
+				y: 8
+			},
+			{
+				id: 9,
+				name: "Oak Hill",
+				x: 12,
+				y: 86
+			}
+		]
+	},
+	{
+		family: "routing",
+		name: "Kyiv Drone Resupply Run",
+		description: "A logistics drone must visit twelve forward supply caches and return to base on one battery. Every wasted kilometer is flight time the battery does not have.",
+		nodes: [
+			{
+				id: 0,
+				name: "Base",
+				x: 50,
+				y: 92
+			},
+			{
+				id: 1,
+				name: "Cache Alpha",
+				x: 18,
+				y: 74
+			},
+			{
+				id: 2,
+				name: "Cache Bravo",
+				x: 10,
+				y: 48
+			},
+			{
+				id: 3,
+				name: "Cache Charlie",
+				x: 24,
+				y: 22
+			},
+			{
+				id: 4,
+				name: "Cache Delta",
+				x: 44,
+				y: 10
+			},
+			{
+				id: 5,
+				name: "Cache Echo",
+				x: 66,
+				y: 14
+			},
+			{
+				id: 6,
+				name: "Cache Foxtrot",
+				x: 86,
+				y: 26
+			},
+			{
+				id: 7,
+				name: "Cache Golf",
+				x: 92,
+				y: 52
+			},
+			{
+				id: 8,
+				name: "Cache Hotel",
+				x: 80,
+				y: 72
+			},
+			{
+				id: 9,
+				name: "Cache India",
+				x: 62,
+				y: 56
+			},
+			{
+				id: 10,
+				name: "Cache Juliet",
+				x: 38,
+				y: 44
+			},
+			{
+				id: 11,
+				name: "Cache Kilo",
+				x: 30,
+				y: 60
+			}
+		]
+	},
+	{
+		family: "routing",
+		name: "Hill Country Brewery Tour",
+		description: "Eight breweries, one designated-driver van, and a hard rule: end where you started. Minimize the drive so there is more time for the beer.",
+		nodes: [
+			{
+				id: 0,
+				name: "Depot (Dripping Springs)",
+				x: 20,
+				y: 60
+			},
+			{
+				id: 1,
+				name: "Jester King",
+				x: 32,
+				y: 48
+			},
+			{
+				id: 2,
+				name: "Vista Brewing",
+				x: 16,
+				y: 78
+			},
+			{
+				id: 3,
+				name: "Treaty Oak",
+				x: 28,
+				y: 70
+			},
+			{
+				id: 4,
+				name: "Last Stand",
+				x: 46,
+				y: 38
+			},
+			{
+				id: 5,
+				name: "Fitzhugh Brewing",
+				x: 40,
+				y: 56
+			},
+			{
+				id: 6,
+				name: "Family Business",
+				x: 60,
+				y: 30
+			},
+			{
+				id: 7,
+				name: "Suds Monkey",
+				x: 24,
+				y: 52
+			}
+		]
+	}
+];
+const packingSampleProblems = [
+	{
+		family: "packing",
+		name: "Mars Cargo Manifest",
+		description: "Fourteen payload modules must ride to orbit in standardized cargo pods. Every pod you do not launch saves nine figures.",
+		binCapacity: 100,
+		binLabel: "pod",
+		items: [
+			{
+				id: 0,
+				name: "Habitat Frame",
+				size: 62
+			},
+			{
+				id: 1,
+				name: "Water Recycler",
+				size: 48
+			},
+			{
+				id: 2,
+				name: "Solar Array A",
+				size: 55
+			},
+			{
+				id: 3,
+				name: "Solar Array B",
+				size: 55
+			},
+			{
+				id: 4,
+				name: "Rover Chassis",
+				size: 70
+			},
+			{
+				id: 5,
+				name: "Lab Module",
+				size: 38
+			},
+			{
+				id: 6,
+				name: "Greenhouse Kit",
+				size: 42
+			},
+			{
+				id: 7,
+				name: "Battery Bank",
+				size: 30
+			},
+			{
+				id: 8,
+				name: "Antenna Mast",
+				size: 22
+			},
+			{
+				id: 9,
+				name: "Med Bay Kit",
+				size: 26
+			},
+			{
+				id: 10,
+				name: "Spare Parts Crate",
+				size: 18
+			},
+			{
+				id: 11,
+				name: "Food Stores",
+				size: 44
+			},
+			{
+				id: 12,
+				name: "Drill Assembly",
+				size: 34
+			},
+			{
+				id: 13,
+				name: "3D Printer",
+				size: 16
+			}
+		]
+	},
+	{
+		family: "packing",
+		name: "Moving Day — Oak Hill",
+		description: "Everything Erik owns has to fit into rented trucks. Each truck costs $180 a day, so the optimizer IS the budget.",
+		binCapacity: 80,
+		binLabel: "truck",
+		items: [
+			{
+				id: 0,
+				name: "Couch",
+				size: 40
+			},
+			{
+				id: 1,
+				name: "Bed Frame",
+				size: 32
+			},
+			{
+				id: 2,
+				name: "Mattress",
+				size: 28
+			},
+			{
+				id: 3,
+				name: "Dining Table",
+				size: 30
+			},
+			{
+				id: 4,
+				name: "Bookshelves",
+				size: 24
+			},
+			{
+				id: 5,
+				name: "Desk Battlestation",
+				size: 36
+			},
+			{
+				id: 6,
+				name: "Arcade Cabinet",
+				size: 44
+			},
+			{
+				id: 7,
+				name: "Kitchen Boxes",
+				size: 20
+			},
+			{
+				id: 8,
+				name: "Book Boxes",
+				size: 26
+			},
+			{
+				id: 9,
+				name: "Garage Tools",
+				size: 18
+			},
+			{
+				id: 10,
+				name: "Bikes",
+				size: 16
+			},
+			{
+				id: 11,
+				name: "Server Rack",
+				size: 22
+			}
+		]
+	},
+	{
+		family: "packing",
+		name: "Server Rack Tetris",
+		description: "Thirteen VM workloads need hosts. Each host burns power whether it is full or idle — consolidate or pay.",
+		binCapacity: 64,
+		binLabel: "host",
+		items: [
+			{
+				id: 0,
+				name: "Postgres Primary",
+				size: 32
+			},
+			{
+				id: 1,
+				name: "Postgres Replica",
+				size: 24
+			},
+			{
+				id: 2,
+				name: "Web Frontend x4",
+				size: 16
+			},
+			{
+				id: 3,
+				name: "API Cluster",
+				size: 28
+			},
+			{
+				id: 4,
+				name: "Redis Cache",
+				size: 12
+			},
+			{
+				id: 5,
+				name: "ML Inference",
+				size: 48
+			},
+			{
+				id: 6,
+				name: "CI Runners",
+				size: 20
+			},
+			{
+				id: 7,
+				name: "Log Pipeline",
+				size: 14
+			},
+			{
+				id: 8,
+				name: "Metrics Stack",
+				size: 18
+			},
+			{
+				id: 9,
+				name: "Batch ETL",
+				size: 26
+			},
+			{
+				id: 10,
+				name: "Search Index",
+				size: 22
+			},
+			{
+				id: 11,
+				name: "Mail Service",
+				size: 8
+			},
+			{
+				id: 12,
+				name: "Backup Agent",
+				size: 10
+			}
+		]
+	}
+];
+const assignmentSampleProblems = [
+	{
+		family: "assignment",
+		name: "Raid Roster",
+		description: "Eight raiders, eight roles, one progression night. The cost matrix is each player&apos;s discomfort in each role — minimize total grumbling.",
+		agents: [
+			{
+				id: 0,
+				name: "Thorgrim"
+			},
+			{
+				id: 1,
+				name: "Lyralei"
+			},
+			{
+				id: 2,
+				name: "Mogrash"
+			},
+			{
+				id: 3,
+				name: "Seraphine"
+			},
+			{
+				id: 4,
+				name: "Kettle"
+			},
+			{
+				id: 5,
+				name: "Vexx"
+			},
+			{
+				id: 6,
+				name: "Oakenheart"
+			},
+			{
+				id: 7,
+				name: "Zinnia"
+			}
+		],
+		tasks: [
+			{
+				id: 0,
+				name: "Main Tank"
+			},
+			{
+				id: 1,
+				name: "Off Tank"
+			},
+			{
+				id: 2,
+				name: "Healer 1"
+			},
+			{
+				id: 3,
+				name: "Healer 2"
+			},
+			{
+				id: 4,
+				name: "Melee DPS"
+			},
+			{
+				id: 5,
+				name: "Ranged DPS"
+			},
+			{
+				id: 6,
+				name: "Raid Lead"
+			},
+			{
+				id: 7,
+				name: "Loot Council"
+			}
+		],
+		cost: [
+			[
+				2,
+				4,
+				9,
+				9,
+				5,
+				7,
+				6,
+				8
+			],
+			[
+				9,
+				8,
+				2,
+				3,
+				7,
+				5,
+				6,
+				4
+			],
+			[
+				3,
+				2,
+				9,
+				8,
+				4,
+				6,
+				7,
+				9
+			],
+			[
+				8,
+				9,
+				3,
+				2,
+				6,
+				4,
+				5,
+				6
+			],
+			[
+				7,
+				6,
+				5,
+				5,
+				2,
+				3,
+				8,
+				7
+			],
+			[
+				6,
+				7,
+				6,
+				6,
+				3,
+				2,
+				4,
+				5
+			],
+			[
+				4,
+				3,
+				7,
+				7,
+				5,
+				6,
+				2,
+				3
+			],
+			[
+				9,
+				8,
+				4,
+				4,
+				6,
+				5,
+				3,
+				2
+			]
+		]
+	},
+	{
+		family: "assignment",
+		name: "Surgery Suite Staffing",
+		description: "Six surgeons, six operating rooms with different specialties on the board today. Cost = mismatch between surgeon expertise and case type.",
+		agents: [
+			{
+				id: 0,
+				name: "Dr. Asante"
+			},
+			{
+				id: 1,
+				name: "Dr. Brook"
+			},
+			{
+				id: 2,
+				name: "Dr. Chen"
+			},
+			{
+				id: 3,
+				name: "Dr. Duarte"
+			},
+			{
+				id: 4,
+				name: "Dr. Eze"
+			},
+			{
+				id: 5,
+				name: "Dr. Farrow"
+			}
+		],
+		tasks: [
+			{
+				id: 0,
+				name: "OR-1 Cardiac"
+			},
+			{
+				id: 1,
+				name: "OR-2 Ortho"
+			},
+			{
+				id: 2,
+				name: "OR-3 Neuro"
+			},
+			{
+				id: 3,
+				name: "OR-4 General"
+			},
+			{
+				id: 4,
+				name: "OR-5 Pediatric"
+			},
+			{
+				id: 5,
+				name: "OR-6 Trauma"
+			}
+		],
+		cost: [
+			[
+				1,
+				8,
+				9,
+				4,
+				7,
+				5
+			],
+			[
+				9,
+				1,
+				8,
+				5,
+				6,
+				3
+			],
+			[
+				8,
+				9,
+				1,
+				6,
+				5,
+				7
+			],
+			[
+				5,
+				4,
+				7,
+				1,
+				3,
+				2
+			],
+			[
+				7,
+				6,
+				5,
+				3,
+				1,
+				4
+			],
+			[
+				4,
+				3,
+				6,
+				2,
+				4,
+				1
+			]
+		]
+	},
+	{
+		family: "assignment",
+		name: "Support Ticket Triage",
+		description: "Seven engineers, nine open escalations — two will wait. Cost = estimated hours for each engineer on each ticket given their domain depth.",
+		agents: [
+			{
+				id: 0,
+				name: "Imani"
+			},
+			{
+				id: 1,
+				name: "Jonas"
+			},
+			{
+				id: 2,
+				name: "Kai"
+			},
+			{
+				id: 3,
+				name: "Lena"
+			},
+			{
+				id: 4,
+				name: "Marcus"
+			},
+			{
+				id: 5,
+				name: "Noor"
+			},
+			{
+				id: 6,
+				name: "Owen"
+			}
+		],
+		tasks: [
+			{
+				id: 0,
+				name: "Auth outage"
+			},
+			{
+				id: 1,
+				name: "Billing drift"
+			},
+			{
+				id: 2,
+				name: "Mobile crash"
+			},
+			{
+				id: 3,
+				name: "Search latency"
+			},
+			{
+				id: 4,
+				name: "Data export"
+			},
+			{
+				id: 5,
+				name: "Webhook storm"
+			},
+			{
+				id: 6,
+				name: "SSO config"
+			},
+			{
+				id: 7,
+				name: "Rate limiter"
+			},
+			{
+				id: 8,
+				name: "PDF renderer"
+			}
+		],
+		cost: [
+			[
+				2,
+				7,
+				9,
+				6,
+				5,
+				4,
+				3,
+				5,
+				8
+			],
+			[
+				8,
+				2,
+				7,
+				5,
+				3,
+				6,
+				7,
+				6,
+				4
+			],
+			[
+				9,
+				6,
+				2,
+				7,
+				6,
+				5,
+				8,
+				7,
+				3
+			],
+			[
+				4,
+				5,
+				6,
+				2,
+				4,
+				3,
+				5,
+				2,
+				7
+			],
+			[
+				6,
+				3,
+				8,
+				4,
+				2,
+				7,
+				6,
+				5,
+				5
+			],
+			[
+				3,
+				6,
+				5,
+				3,
+				7,
+				2,
+				2,
+				4,
+				6
+			],
+			[
+				7,
+				4,
+				4,
+				8,
+				5,
+				6,
+				4,
+				3,
+				2
+			]
+		]
+	}
+];
+const networkSampleProblems = [
+	{
+		family: "network",
+		name: "Office Seating Feud",
+		description: "Ten coworkers, weighted rivalry edges (1 = mild eye-rolls, 5 = open warfare). Split them across two floors so the maximum total rivalry crosses the staircase.",
+		nodes: [
+			{
+				id: 0,
+				name: "Ava",
+				x: 20,
+				y: 20
+			},
+			{
+				id: 1,
+				name: "Ben",
+				x: 50,
+				y: 12
+			},
+			{
+				id: 2,
+				name: "Cleo",
+				x: 80,
+				y: 22
+			},
+			{
+				id: 3,
+				name: "Dex",
+				x: 12,
+				y: 50
+			},
+			{
+				id: 4,
+				name: "Elle",
+				x: 42,
+				y: 42
+			},
+			{
+				id: 5,
+				name: "Finn",
+				x: 70,
+				y: 48
+			},
+			{
+				id: 6,
+				name: "Gus",
+				x: 92,
+				y: 55
+			},
+			{
+				id: 7,
+				name: "Hana",
+				x: 25,
+				y: 80
+			},
+			{
+				id: 8,
+				name: "Iggy",
+				x: 55,
+				y: 84
+			},
+			{
+				id: 9,
+				name: "June",
+				x: 82,
+				y: 80
+			}
+		],
+		edges: [
+			{
+				a: 0,
+				b: 1,
+				w: 3
+			},
+			{
+				a: 0,
+				b: 3,
+				w: 1
+			},
+			{
+				a: 0,
+				b: 4,
+				w: 4
+			},
+			{
+				a: 1,
+				b: 2,
+				w: 2
+			},
+			{
+				a: 1,
+				b: 4,
+				w: 5
+			},
+			{
+				a: 2,
+				b: 5,
+				w: 3
+			},
+			{
+				a: 2,
+				b: 6,
+				w: 1
+			},
+			{
+				a: 3,
+				b: 4,
+				w: 2
+			},
+			{
+				a: 3,
+				b: 7,
+				w: 4
+			},
+			{
+				a: 4,
+				b: 5,
+				w: 1
+			},
+			{
+				a: 4,
+				b: 8,
+				w: 3
+			},
+			{
+				a: 5,
+				b: 6,
+				w: 4
+			},
+			{
+				a: 5,
+				b: 9,
+				w: 2
+			},
+			{
+				a: 6,
+				b: 9,
+				w: 5
+			},
+			{
+				a: 7,
+				b: 8,
+				w: 2
+			},
+			{
+				a: 8,
+				b: 9,
+				w: 1
+			}
+		]
+	},
+	{
+		family: "network",
+		name: "Microservice Fault Domains",
+		description: "Twelve services, edges weighted by cross-talk volume. Split across two availability zones so the heaviest traffic crosses zones — forcing the chattiest pairs to prove they tolerate partition.",
+		nodes: [
+			{
+				id: 0,
+				name: "gateway",
+				x: 50,
+				y: 8
+			},
+			{
+				id: 1,
+				name: "auth",
+				x: 25,
+				y: 22
+			},
+			{
+				id: 2,
+				name: "users",
+				x: 75,
+				y: 22
+			},
+			{
+				id: 3,
+				name: "billing",
+				x: 12,
+				y: 46
+			},
+			{
+				id: 4,
+				name: "catalog",
+				x: 40,
+				y: 40
+			},
+			{
+				id: 5,
+				name: "orders",
+				x: 64,
+				y: 42
+			},
+			{
+				id: 6,
+				name: "search",
+				x: 90,
+				y: 44
+			},
+			{
+				id: 7,
+				name: "ledger",
+				x: 20,
+				y: 70
+			},
+			{
+				id: 8,
+				name: "shipping",
+				x: 48,
+				y: 68
+			},
+			{
+				id: 9,
+				name: "notify",
+				x: 74,
+				y: 70
+			},
+			{
+				id: 10,
+				name: "analytics",
+				x: 34,
+				y: 90
+			},
+			{
+				id: 11,
+				name: "ml-recs",
+				x: 66,
+				y: 90
+			}
+		],
+		edges: [
+			{
+				a: 0,
+				b: 1,
+				w: 5
+			},
+			{
+				a: 0,
+				b: 2,
+				w: 4
+			},
+			{
+				a: 0,
+				b: 4,
+				w: 3
+			},
+			{
+				a: 1,
+				b: 2,
+				w: 2
+			},
+			{
+				a: 1,
+				b: 3,
+				w: 3
+			},
+			{
+				a: 2,
+				b: 5,
+				w: 4
+			},
+			{
+				a: 2,
+				b: 6,
+				w: 2
+			},
+			{
+				a: 3,
+				b: 7,
+				w: 5
+			},
+			{
+				a: 4,
+				b: 5,
+				w: 3
+			},
+			{
+				a: 4,
+				b: 6,
+				w: 2
+			},
+			{
+				a: 4,
+				b: 11,
+				w: 2
+			},
+			{
+				a: 5,
+				b: 8,
+				w: 4
+			},
+			{
+				a: 5,
+				b: 9,
+				w: 2
+			},
+			{
+				a: 7,
+				b: 10,
+				w: 2
+			},
+			{
+				a: 8,
+				b: 9,
+				w: 3
+			},
+			{
+				a: 8,
+				b: 10,
+				w: 1
+			},
+			{
+				a: 9,
+				b: 11,
+				w: 2
+			},
+			{
+				a: 10,
+				b: 11,
+				w: 3
+			}
+		]
+	},
+	{
+		family: "network",
+		name: "Power Grid Islanding",
+		description: "During a storm event, the grid must split into two self-sufficient islands. Maximize the inter-island line capacity you can afford to sever cleanly.",
+		nodes: [
+			{
+				id: 0,
+				name: "Plant North",
+				x: 30,
+				y: 10
+			},
+			{
+				id: 1,
+				name: "Plant South",
+				x: 65,
+				y: 90
+			},
+			{
+				id: 2,
+				name: "Sub Alpha",
+				x: 15,
+				y: 35
+			},
+			{
+				id: 3,
+				name: "Sub Bravo",
+				x: 50,
+				y: 28
+			},
+			{
+				id: 4,
+				name: "Sub Charlie",
+				x: 85,
+				y: 32
+			},
+			{
+				id: 5,
+				name: "Sub Delta",
+				x: 25,
+				y: 62
+			},
+			{
+				id: 6,
+				name: "Sub Echo",
+				x: 58,
+				y: 58
+			},
+			{
+				id: 7,
+				name: "Sub Foxtrot",
+				x: 88,
+				y: 66
+			},
+			{
+				id: 8,
+				name: "City West",
+				x: 12,
+				y: 88
+			}
+		],
+		edges: [
+			{
+				a: 0,
+				b: 2,
+				w: 4
+			},
+			{
+				a: 0,
+				b: 3,
+				w: 5
+			},
+			{
+				a: 0,
+				b: 4,
+				w: 3
+			},
+			{
+				a: 2,
+				b: 3,
+				w: 2
+			},
+			{
+				a: 2,
+				b: 5,
+				w: 4
+			},
+			{
+				a: 3,
+				b: 4,
+				w: 2
+			},
+			{
+				a: 3,
+				b: 6,
+				w: 4
+			},
+			{
+				a: 4,
+				b: 7,
+				w: 4
+			},
+			{
+				a: 5,
+				b: 6,
+				w: 3
+			},
+			{
+				a: 5,
+				b: 8,
+				w: 5
+			},
+			{
+				a: 6,
+				b: 7,
+				w: 2
+			},
+			{
+				a: 6,
+				b: 1,
+				w: 5
+			},
+			{
+				a: 7,
+				b: 1,
+				w: 3
+			},
+			{
+				a: 8,
+				b: 1,
+				w: 2
+			}
+		]
+	}
+];
+/** Build a jittered grid mesh: cells at (col,row), edges between face-sharing neighbors. */
+function gridMesh(cols, rows, cellName, weightAt, jitter) {
+	const nodes = [];
+	const padX = 100 / (cols + 1);
+	const padY = 100 / (rows + 1);
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+		const i = r * cols + c;
+		const { dx, dy } = jitter(i);
+		nodes.push({
+			id: i,
+			name: cellName(i),
+			x: Math.round(padX * (c + 1) + dx),
+			y: Math.round(padY * (r + 1) + dy)
+		});
+	}
+	const edges = [];
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+		const i = r * cols + c;
+		if (c + 1 < cols) edges.push({
+			a: i,
+			b: i + 1,
+			w: weightAt(i, i + 1)
+		});
+		if (r + 1 < rows) edges.push({
+			a: i,
+			b: i + cols,
+			w: weightAt(i, i + cols)
+		});
+	}
+	return {
+		nodes,
+		edges
+	};
+}
+const wobble = (i) => i * 7919 % 11 / 10 - .5;
+const plate = gridMesh(4, 3, (i) => `cell ${i}`, (a, b) => 1 + (a * 31 + b * 17) % 4, (i) => ({
+	dx: wobble(i) * 6,
+	dy: wobble(i + 3) * 6
+}));
+const reservoir = gridMesh(6, 3, (i) => `block ${i}`, (a, b) => 1 + (a * 13 + b * 29) % 5, (i) => ({
+	dx: wobble(i + 1) * 8,
+	dy: wobble(i + 5) * 8
+}));
+const blade = gridMesh(6, 4, (i) => `elem ${i}`, (a, b) => 1 + (a * 23 + b * 19) % 4, (i) => ({
+	dx: wobble(i + 2) * 7,
+	dy: wobble(i + 7) * 7
+}));
+const partitioningSampleProblems = [
+	{
+		family: "partitioning",
+		name: "Cantilever Plate Mesh",
+		description: "A 4×3 finite-element plate mesh split across two solver ranks. Edge weights are the face data exchanged every timestep — each cut edge is halo traffic both ranks pay forever. Classic balanced bisection, and small enough to race on the QAOA simulator in seconds.",
+		nodes: plate.nodes,
+		edges: plate.edges,
+		k: 2,
+		balanceTolerance: 1
+	},
+	{
+		family: "partitioning",
+		name: "Reservoir Grid Sectors",
+		description: "An 18-block reservoir simulation grid decomposed across three compute nodes. The big version of this problem has billions of cells; the math of where to draw the seams is identical at every scale.",
+		nodes: reservoir.nodes,
+		edges: reservoir.edges,
+		k: 3,
+		balanceTolerance: 1
+	},
+	{
+		family: "partitioning",
+		name: "Turbine Blade Mesh",
+		description: "A 24-element blade section spread over four solver ranks for a transient thermal run. Four-way splits punish lazy seams — every extra cut edge multiplies across thousands of timesteps.",
+		nodes: blade.nodes,
+		edges: blade.edges,
+		k: 4,
+		balanceTolerance: 1
+	}
+];
+const selectionSampleProblems = [
+	{
+		family: "selection",
+		name: "Indie Game Fund",
+		description: "Twelve pitches, a $2M fund, and every project carries risk. Maximize expected portfolio value without betting the firm on moonshots.",
+		budget: 200,
+		riskWeight: 4,
+		items: [
+			{
+				id: 0,
+				name: "Cozy Farm Sim",
+				value: 60,
+				cost: 40,
+				risk: 2
+			},
+			{
+				id: 1,
+				name: "Roguelike Deckbuilder",
+				value: 85,
+				cost: 55,
+				risk: 4
+			},
+			{
+				id: 2,
+				name: "VR Escape Room",
+				value: 95,
+				cost: 70,
+				risk: 8
+			},
+			{
+				id: 3,
+				name: "Pixel Metroidvania",
+				value: 55,
+				cost: 35,
+				risk: 3
+			},
+			{
+				id: 4,
+				name: "MMO Sandbox",
+				value: 160,
+				cost: 120,
+				risk: 10
+			},
+			{
+				id: 5,
+				name: "Mobile Puzzler",
+				value: 35,
+				cost: 18,
+				risk: 1
+			},
+			{
+				id: 6,
+				name: "Co-op Heist Game",
+				value: 75,
+				cost: 50,
+				risk: 5
+			},
+			{
+				id: 7,
+				name: "Narrative Adventure",
+				value: 45,
+				cost: 30,
+				risk: 2
+			},
+			{
+				id: 8,
+				name: "Auto-Battler",
+				value: 50,
+				cost: 28,
+				risk: 4
+			},
+			{
+				id: 9,
+				name: "Speedrun Platformer",
+				value: 30,
+				cost: 15,
+				risk: 2
+			},
+			{
+				id: 10,
+				name: "City Builder",
+				value: 90,
+				cost: 65,
+				risk: 5
+			},
+			{
+				id: 11,
+				name: "Horror Anthology",
+				value: 40,
+				cost: 25,
+				risk: 6
+			}
+		]
+	},
+	{
+		family: "selection",
+		name: "Drone Sensor Loadout",
+		description: "A recon drone has 48 units of payload mass. Pick the sensor suite that maximizes mission value — leave the gold-plated gear on the bench.",
+		budget: 48,
+		riskWeight: 0,
+		items: [
+			{
+				id: 0,
+				name: "EO Camera",
+				value: 30,
+				cost: 12
+			},
+			{
+				id: 1,
+				name: "IR Thermal",
+				value: 28,
+				cost: 10
+			},
+			{
+				id: 2,
+				name: "LIDAR",
+				value: 35,
+				cost: 18
+			},
+			{
+				id: 3,
+				name: "SIGINT Pod",
+				value: 25,
+				cost: 14
+			},
+			{
+				id: 4,
+				name: "Synthetic Aperture Radar",
+				value: 40,
+				cost: 22
+			},
+			{
+				id: 5,
+				name: "Laser Designator",
+				value: 18,
+				cost: 8
+			},
+			{
+				id: 6,
+				name: "Comms Relay",
+				value: 15,
+				cost: 6
+			},
+			{
+				id: 7,
+				name: "Magnetometer",
+				value: 10,
+				cost: 4
+			},
+			{
+				id: 8,
+				name: "Air Sampler",
+				value: 8,
+				cost: 5
+			},
+			{
+				id: 9,
+				name: "Spare Battery",
+				value: 12,
+				cost: 9
+			}
+		]
+	},
+	{
+		family: "selection",
+		name: "Feature Flag Quarter",
+		description: "Fourteen engineering initiatives, 90 days of team capacity. Each carries delivery risk. Choose the roadmap that maximizes shipped value.",
+		budget: 90,
+		riskWeight: 3,
+		items: [
+			{
+				id: 0,
+				name: "Realtime Collab",
+				value: 55,
+				cost: 30,
+				risk: 6
+			},
+			{
+				id: 1,
+				name: "Mobile Offline Mode",
+				value: 40,
+				cost: 25,
+				risk: 4
+			},
+			{
+				id: 2,
+				name: "SSO Everywhere",
+				value: 35,
+				cost: 15,
+				risk: 2
+			},
+			{
+				id: 3,
+				name: "Billing v2",
+				value: 50,
+				cost: 35,
+				risk: 7
+			},
+			{
+				id: 4,
+				name: "AI Summaries",
+				value: 45,
+				cost: 20,
+				risk: 3
+			},
+			{
+				id: 5,
+				name: "Audit Logs",
+				value: 25,
+				cost: 10,
+				risk: 1
+			},
+			{
+				id: 6,
+				name: "Perf: Cold Start",
+				value: 30,
+				cost: 12,
+				risk: 2
+			},
+			{
+				id: 7,
+				name: "Theme System",
+				value: 15,
+				cost: 8,
+				risk: 1
+			},
+			{
+				id: 8,
+				name: "Webhooks v2",
+				value: 28,
+				cost: 14,
+				risk: 3
+			},
+			{
+				id: 9,
+				name: "Data Residency",
+				value: 38,
+				cost: 28,
+				risk: 5
+			},
+			{
+				id: 10,
+				name: "Search Rewrite",
+				value: 42,
+				cost: 26,
+				risk: 5
+			},
+			{
+				id: 11,
+				name: "Onboarding Flow",
+				value: 22,
+				cost: 9,
+				risk: 1
+			},
+			{
+				id: 12,
+				name: "Plugin SDK",
+				value: 48,
+				cost: 32,
+				risk: 6
+			},
+			{
+				id: 13,
+				name: "A11y Sweep",
+				value: 20,
+				cost: 11,
+				risk: 1
+			}
+		]
+	}
+];
+const economicSampleProblems = [
+	{
+		family: "economic",
+		name: "Spectrum Auction",
+		description: "Five regional spectrum licenses, nine carriers bidding on bundles. Sell each license once, maximize treasury revenue — the classic FCC winner-determination problem.",
+		goods: [
+			{
+				id: 0,
+				name: "North Band"
+			},
+			{
+				id: 1,
+				name: "South Band"
+			},
+			{
+				id: 2,
+				name: "East Band"
+			},
+			{
+				id: 3,
+				name: "West Band"
+			},
+			{
+				id: 4,
+				name: "Metro Core"
+			}
+		],
+		bids: [
+			{
+				id: 0,
+				bidder: "AstraTel",
+				price: 120,
+				goodIds: [0, 4]
+			},
+			{
+				id: 1,
+				bidder: "AstraTel",
+				price: 60,
+				goodIds: [0]
+			},
+			{
+				id: 2,
+				bidder: "Borealis",
+				price: 140,
+				goodIds: [1, 2]
+			},
+			{
+				id: 3,
+				bidder: "Borealis",
+				price: 65,
+				goodIds: [1]
+			},
+			{
+				id: 4,
+				bidder: "CometNet",
+				price: 95,
+				goodIds: [2, 3]
+			},
+			{
+				id: 5,
+				bidder: "CometNet",
+				price: 50,
+				goodIds: [3]
+			},
+			{
+				id: 6,
+				bidder: "DyneMobile",
+				price: 180,
+				goodIds: [
+					0,
+					1,
+					4
+				]
+			},
+			{
+				id: 7,
+				bidder: "Equinox",
+				price: 75,
+				goodIds: [4]
+			},
+			{
+				id: 8,
+				bidder: "Equinox",
+				price: 110,
+				goodIds: [2, 4]
+			}
+		]
+	},
+	{
+		family: "economic",
+		name: "Cloud Spot Market",
+		description: "Six GPU node pools, ten batch workloads bidding for exclusive overnight windows. Maximize the operator&apos;s take across all-or-nothing reservations.",
+		goods: [
+			{
+				id: 0,
+				name: "A100 Pool 1"
+			},
+			{
+				id: 1,
+				name: "A100 Pool 2"
+			},
+			{
+				id: 2,
+				name: "H100 Pool 1"
+			},
+			{
+				id: 3,
+				name: "H100 Pool 2"
+			},
+			{
+				id: 4,
+				name: "TPU Pod"
+			},
+			{
+				id: 5,
+				name: "CPU Farm"
+			}
+		],
+		bids: [
+			{
+				id: 0,
+				bidder: "BioFold Labs",
+				price: 90,
+				goodIds: [2, 3]
+			},
+			{
+				id: 1,
+				bidder: "BioFold Labs",
+				price: 48,
+				goodIds: [2]
+			},
+			{
+				id: 2,
+				bidder: "RenderWorks",
+				price: 55,
+				goodIds: [0, 1]
+			},
+			{
+				id: 3,
+				bidder: "RenderWorks",
+				price: 30,
+				goodIds: [0]
+			},
+			{
+				id: 4,
+				bidder: "LLM Foundry",
+				price: 130,
+				goodIds: [
+					2,
+					3,
+					4
+				]
+			},
+			{
+				id: 5,
+				bidder: "LLM Foundry",
+				price: 70,
+				goodIds: [4]
+			},
+			{
+				id: 6,
+				bidder: "QuantSim",
+				price: 42,
+				goodIds: [1, 5]
+			},
+			{
+				id: 7,
+				bidder: "QuantSim",
+				price: 22,
+				goodIds: [5]
+			},
+			{
+				id: 8,
+				bidder: "WeatherNet",
+				price: 65,
+				goodIds: [0, 5]
+			},
+			{
+				id: 9,
+				bidder: "GenomeScan",
+				price: 38,
+				goodIds: [1]
+			}
+		]
+	},
+	{
+		family: "economic",
+		name: "Stadium Sponsorship Bundle",
+		description: "Seven sponsorship assets — naming rights, jersey patch, tunnel club — and eight brands bidding on combinations. One sale per asset; maximize the franchise&apos;s deal sheet.",
+		goods: [
+			{
+				id: 0,
+				name: "Naming Rights"
+			},
+			{
+				id: 1,
+				name: "Jersey Patch"
+			},
+			{
+				id: 2,
+				name: "Tunnel Club"
+			},
+			{
+				id: 3,
+				name: "Scoreboard"
+			},
+			{
+				id: 4,
+				name: "Practice Facility"
+			},
+			{
+				id: 5,
+				name: "Beer Pouring Rights"
+			},
+			{
+				id: 6,
+				name: "Halftime Show"
+			}
+		],
+		bids: [
+			{
+				id: 0,
+				bidder: "Vertex Air",
+				price: 200,
+				goodIds: [0, 3]
+			},
+			{
+				id: 1,
+				bidder: "Vertex Air",
+				price: 130,
+				goodIds: [0]
+			},
+			{
+				id: 2,
+				bidder: "Cascade Beer",
+				price: 85,
+				goodIds: [5, 6]
+			},
+			{
+				id: 3,
+				bidder: "Cascade Beer",
+				price: 55,
+				goodIds: [5]
+			},
+			{
+				id: 4,
+				bidder: "NovaBank",
+				price: 150,
+				goodIds: [1, 2]
+			},
+			{
+				id: 5,
+				bidder: "NovaBank",
+				price: 80,
+				goodIds: [1]
+			},
+			{
+				id: 6,
+				bidder: "GrindHouse Coffee",
+				price: 45,
+				goodIds: [2]
+			},
+			{
+				id: 7,
+				bidder: "Pixel Motors",
+				price: 110,
+				goodIds: [3, 4]
+			},
+			{
+				id: 8,
+				bidder: "Pixel Motors",
+				price: 60,
+				goodIds: [4]
+			},
+			{
+				id: 9,
+				bidder: "StreamCo",
+				price: 70,
+				goodIds: [6]
+			}
+		]
 	}
-	const edges = [];
-	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
-		const i = r * cols + c;
-		if (c + 1 < cols) edges.push({
-			a: i,
-			b: i + 1,
-			w: weightAt(i, i + 1)
-		});
-		if (r + 1 < rows) edges.push({
-			a: i,
-			b: i + cols,
-			w: weightAt(i, i + cols)
-		});
+];
+const continuousSampleProblems = [
+	{
+		family: "continuous",
+		name: "Reactor Temperature Tuning",
+		description: "One control dial, a yield curve full of local sweet spots, and exactly one true optimum. The wavy bowl eats naive hill climbers for breakfast.",
+		functionId: "wavy-bowl",
+		dims: 1,
+		lo: -10,
+		hi: 10,
+		paramNames: ["temperature offset"]
+	},
+	{
+		family: "continuous",
+		name: "Antenna Sweet Spot",
+		description: "Two placement coordinates on the roof; signal interference makes four equally good mounting points. Himmelblau&apos;s function — which optimum will your solver find?",
+		functionId: "himmelblau",
+		dims: 2,
+		lo: -6,
+		hi: 6,
+		paramNames: ["east-west", "north-south"]
+	},
+	{
+		family: "continuous",
+		name: "Hyperparameter Canyon",
+		description: "Two training knobs over a Rastrigin egg-carton — dozens of local minima arranged in a lattice, one global floor at the origin. Pure trap density.",
+		functionId: "rastrigin",
+		dims: 2,
+		lo: -5.12,
+		hi: 5.12,
+		paramNames: ["learning rate (scaled)", "regularization (scaled)"]
 	}
-	return {
-		nodes,
-		edges
-	};
-}
-const wobble = (i) => i * 7919 % 11 / 10 - .5;
-const plate = gridMesh(4, 3, (i) => `cell ${i}`, (a, b) => 1 + (a * 31 + b * 17) % 4, (i) => ({
-	dx: wobble(i) * 6,
-	dy: wobble(i + 3) * 6
-}));
-const reservoir = gridMesh(6, 3, (i) => `block ${i}`, (a, b) => 1 + (a * 13 + b * 29) % 5, (i) => ({
-	dx: wobble(i + 1) * 8,
-	dy: wobble(i + 5) * 8
-}));
-const blade = gridMesh(6, 4, (i) => `elem ${i}`, (a, b) => 1 + (a * 23 + b * 19) % 4, (i) => ({
-	dx: wobble(i + 2) * 7,
-	dy: wobble(i + 7) * 7
-}));
-plate.nodes, plate.edges, reservoir.nodes, reservoir.edges, blade.nodes, blade.edges;
+];
 var QuboBuilder = class {
 	size;
 	q = /* @__PURE__ */ new Map();
@@ -11248,8 +13294,270 @@ function continuousToy() {
 	};
 }
 schedulingToy(), routingToy(), packingToy(), assignmentToy(), networkToy(), partitioningToy(), selectionToy(), economicToy(), continuousToy();
+/**
+* Per-family problem Zod schemas — the validation foundation for custom problem
+* EDITING (FamilyProblemEditor validates JSON against these) and LLM FORMULATION
+* (quantum_formulate validates the model's output before surfacing it).
+*
+* Authored to match the hand-written interfaces in `./types`; a type-level check
+* at the bottom keeps the two in sync. The family discriminant lets a single
+* editor/tool dispatch across all eight shapes.
+*/
+const named = {
+	id: z.number().int(),
+	name: z.string().min(1)
+};
+const xy = {
+	x: z.number(),
+	y: z.number()
+};
+const edge = z.object({
+	a: z.number().int().nonnegative(),
+	b: z.number().int().nonnegative(),
+	w: z.number().optional()
+});
+const RoutingProblemSchema = z.object({
+	family: z.literal("routing"),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	nodes: z.array(z.object({
+		...named,
+		...xy
+	})).min(2)
+});
+const PackingProblemSchema = z.object({
+	family: z.literal("packing"),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	items: z.array(z.object({
+		...named,
+		size: z.number().positive()
+	})).min(1),
+	binCapacity: z.number().positive(),
+	binLabel: z.string().min(1)
+});
+const AssignmentProblemSchema = z.object({
+	family: z.literal("assignment"),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	agents: z.array(z.object(named)).min(1),
+	tasks: z.array(z.object(named)).min(1),
+	cost: z.array(z.array(z.number())).min(1)
+});
+const NetworkProblemSchema = z.object({
+	family: z.literal("network"),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	nodes: z.array(z.object({
+		...named,
+		...xy
+	})).min(1),
+	edges: z.array(edge)
+});
+const PartitionProblemSchema = z.object({
+	family: z.literal("partitioning"),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	nodes: z.array(z.object({
+		...named,
+		...xy
+	})).min(1),
+	edges: z.array(edge),
+	k: z.number().int().min(2),
+	balanceTolerance: z.number().int().nonnegative().optional()
+});
+const SelectionProblemSchema = z.object({
+	family: z.literal("selection"),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	items: z.array(z.object({
+		...named,
+		value: z.number(),
+		cost: z.number().positive(),
+		risk: z.number().optional()
+	})).min(1),
+	budget: z.number().positive(),
+	riskWeight: z.number().optional()
+});
+const EconomicProblemSchema = z.object({
+	family: z.literal("economic"),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	goods: z.array(z.object(named)).min(1),
+	bids: z.array(z.object({
+		id: z.number().int(),
+		bidder: z.string().min(1),
+		price: z.number(),
+		goodIds: z.array(z.number().int().nonnegative())
+	})).min(1)
+});
+const ContinuousProblemSchema = z.object({
+	family: z.literal("continuous"),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	functionId: z.enum([
+		"rastrigin",
+		"ackley",
+		"himmelblau",
+		"wavy-bowl"
+	]),
+	dims: z.union([z.literal(1), z.literal(2)]),
+	lo: z.number(),
+	hi: z.number(),
+	paramNames: z.array(z.string())
+});
+z.discriminatedUnion("family", [
+	RoutingProblemSchema,
+	PackingProblemSchema,
+	AssignmentProblemSchema,
+	NetworkProblemSchema,
+	PartitionProblemSchema,
+	SelectionProblemSchema,
+	EconomicProblemSchema,
+	ContinuousProblemSchema
+]);
+const refineAssignment = (p, ctx) => {
+	if (p.cost.length !== p.agents.length) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["cost"],
+		message: `cost must have one row per agent (${p.agents.length}); got ${p.cost.length}`
+	});
+	p.cost.forEach((row, i) => {
+		if (row.length !== p.tasks.length) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["cost", i],
+			message: `cost row ${i} must have one column per task (${p.tasks.length}); got ${row.length}`
+		});
+	});
+};
+const refineEdgeBounds = (p, ctx) => {
+	const n = p.nodes.length;
+	p.edges.forEach((e, i) => {
+		if (e.a >= n || e.b >= n) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["edges", i],
+			message: `edge endpoints must reference nodes 0..${n - 1}; got a=${e.a}, b=${e.b}`
+		});
+	});
+};
+const refineEconomic = (p, ctx) => {
+	const n = p.goods.length;
+	p.bids.forEach((bid, i) => {
+		const seen = /* @__PURE__ */ new Set();
+		bid.goodIds.forEach((g, j) => {
+			if (g >= n) ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: [
+					"bids",
+					i,
+					"goodIds",
+					j
+				],
+				message: `goodId must reference goods 0..${n - 1}; got ${g}`
+			});
+			if (seen.has(g)) ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: [
+					"bids",
+					i,
+					"goodIds",
+					j
+				],
+				message: `duplicate goodId ${g} in bid ${i}`
+			});
+			seen.add(g);
+		});
+	});
+};
+/** Per-family schema lookup — the editor/tool pick the right one by familyId. */
+const FAMILY_PROBLEM_SCHEMAS = {
+	routing: RoutingProblemSchema,
+	packing: PackingProblemSchema,
+	assignment: AssignmentProblemSchema.superRefine(refineAssignment),
+	network: NetworkProblemSchema.superRefine(refineEdgeBounds),
+	partitioning: PartitionProblemSchema.superRefine(refineEdgeBounds),
+	selection: SelectionProblemSchema,
+	economic: EconomicProblemSchema.superRefine(refineEconomic),
+	continuous: ContinuousProblemSchema
+};
+const FAMILY_SAMPLE_PROBLEMS = {
+	routing: routingSampleProblems,
+	packing: packingSampleProblems,
+	assignment: assignmentSampleProblems,
+	network: networkSampleProblems,
+	partitioning: partitioningSampleProblems,
+	selection: selectionSampleProblems,
+	economic: economicSampleProblems,
+	continuous: continuousSampleProblems
+};
 //#endregion
-//#region ../../b4m-core/services/dist/tools-FLVnTwId.mjs
+//#region ../../b4m-core/services/dist/tools-BhiSgg5-.mjs
+const createFabFileSchema = z.object({
+	fileName: z.string(),
+	mimeType: z.string(),
+	fileSize: z.number(),
+	type: z.enum(KnowledgeType),
+	content: z.union([z.string(), z.instanceof(Buffer)]).optional(),
+	organizationId: z.string().optional(),
+	/**
+	* Content type of the file
+	* @example 'text/markdown'
+	* @example 'application/pdf'
+	* @example 'application/octet-stream' for binary files
+	*/
+	contentType: z.string().optional(),
+	public: z.boolean().optional(),
+	prefix: z.string().optional(),
+	system: z.boolean().optional(),
+	tags: z.array(z.object({
+		name: z.string(),
+		strength: z.number()
+	})).optional(),
+	systemPriority: z.number().optional(),
+	sessionId: z.string().optional(),
+	contentHash: z.string().optional(),
+	batchId: z.string().optional(),
+	relativePath: z.string().optional()
+});
+const DEFAULT_MAX_FILE_SIZE = 20;
+const DEFAULT_EXPIRE_IN_SECONDS = 3600 * 24 * 5;
+const createFabFile = async (userId, parameters, { db, storage }) => {
+	const params = secureParameters(parameters, createFabFileSchema);
+	const user = await db.users.findById(userId);
+	if (!user) throw new BadRequestError("User not found");
+	let ext = "";
+	let mimeType = parameters.mimeType;
+	ext = getFileExtension(params.fileName);
+	mimeType = params.mimeType || getMimeTypeByExtension(ext);
+	if (!mimeType) mimeType = SupportedFabFileMimeTypes.TXT_PLAIN;
+	if (!Object.values(SupportedFabFileMimeTypes).some((type) => type === mimeType)) throw new BadRequestError(`File type ${mimeType} is not supported`);
+	let filePath = params.prefix ? `${params.prefix}/` : "";
+	filePath += `${v4()}${ext ? `.${ext}` : ".txt"}`;
+	const maxFileSize = getSettingsValue("MaxFileSize", await getSettingsMap(db), DEFAULT_MAX_FILE_SIZE) * 1024 * 1024;
+	if (params.fileSize >= maxFileSize) throw new BadRequestError("File size exceeds maximum file size");
+	await checkStorageLimitForFile(user, params.fileSize, params.organizationId, db.organizations?.findById);
+	const buildData = {
+		userId,
+		...params,
+		mimeType,
+		filePath,
+		users: [],
+		groups: [],
+		isGlobalRead: false,
+		isGlobalWrite: false,
+		createdAt: /* @__PURE__ */ new Date(),
+		updatedAt: /* @__PURE__ */ new Date()
+	};
+	if (params.content) {
+		await storage.upload(filePath, params.content, {
+			ContentType: params.contentType,
+			ContentLength: params.fileSize
+		});
+		buildData.fileUrl = await storage.generateSignedUrl(filePath, DEFAULT_EXPIRE_IN_SECONDS, "get");
+		buildData.fileUrlExpireAt = new Date(Date.now() + DEFAULT_EXPIRE_IN_SECONDS * 1e3);
+	} else buildData.presignedUrl = await storage.generateSignedUrl(filePath, 600, "put");
+	return await db.fabFiles.create(buildData);
+};
 async function performDeepResearch(context, params, config = {}) {
 	const maxDepth = config.maxDepth || 7;
 	const duration = config.duration || 4.5;
@@ -11610,9 +13918,10 @@ const deepResearchTool = {
 async function getDynamicDataLakeAccess(context) {
 	const userTags = context.user.tags || [];
 	const entitlementKeys = context.entitlementKeys ?? [];
+	const organizationId = context.user.organizationId ? String(context.user.organizationId) : void 0;
 	let dynamicDataLakes;
 	if (context.db.dataLakes) try {
-		dynamicDataLakes = (await context.db.dataLakes.findActiveByUserTagsAndEntitlements(userTags, entitlementKeys)).map(toDataLakeConfig);
+		dynamicDataLakes = (await context.db.dataLakes.findActiveByUserTagsAndEntitlements(userTags, entitlementKeys, organizationId)).map(toDataLakeConfig);
 	} catch {}
 	const accessibleLakes = getAccessibleDataLakes(userTags, dynamicDataLakes, entitlementKeys);
 	return {
@@ -11760,6 +14069,60 @@ const weatherTool = {
 		}
 	})
 };
+/**
+* Persist a tool-generated file (image, Excel, etc.) as a session-scoped FabFile so it
+* shows up in the Knowledge Base / WorkBench and is downloadable after the run.
+*
+* Why this exists: file-generating tools historically only pushed the generated filename
+* into `quest.images` via `statusUpdate`, which (a) renders fine inline for images but is
+* a broken `<img>` for non-image files like .xlsx, and (b) was never recorded as a FabFile,
+* so nothing the user can browse referenced it — the file was effectively orphaned in the
+* generated-content bucket (see prod session 6a41abae…, where 4 agent-generated images were
+* lost entirely). Creating a FabFile with `sessionId` set makes the file appear in the
+* Knowledge Viewer via `useGetFabFilesBySessionId` → `useMessageFiles`.
+*
+* Best-effort: a failure here (missing adapters, storage quota, unsupported mime) must never
+* break the tool itself — the inline `quest.images` render still works. We log and swallow.
+*
+* The file is re-uploaded into the FabFile bucket (`context.storage`) because the Knowledge
+* Viewer reads FabFiles through their signed `fileUrl`, which is issued against that bucket.
+*/
+async function persistGeneratedFileAsFabFile(context, file) {
+	const { sessionId, userId, db, storage, logger } = context;
+	if (!sessionId) return;
+	if (!db.fabfiles || !db.users || !db.adminSettings) {
+		logger.warn("[persistGeneratedFileAsFabFile] missing db adapters — skipping FabFile persist");
+		return;
+	}
+	try {
+		await createFabFile(userId, {
+			fileName: file.fileName,
+			mimeType: file.mimeType,
+			fileSize: file.content.length,
+			type: KnowledgeType.FILE,
+			content: file.content,
+			contentType: file.mimeType,
+			sessionId,
+			prefix: "generated",
+			tags: [{
+				name: "generated",
+				strength: 1
+			}]
+		}, {
+			db: {
+				fabFiles: db.fabfiles,
+				adminSettings: db.adminSettings,
+				users: db.users
+			},
+			storage: {
+				upload: (path, content, options) => storage.upload(content, path, options),
+				generateSignedUrl: (path, expireInSeconds, type) => storage.getSignedUrl(path, type ?? "get", { expiresIn: expireInSeconds })
+			}
+		});
+	} catch (err) {
+		logger.error("[persistGeneratedFileAsFabFile] failed to persist generated file (non-fatal)", err);
+	}
+}
 async function downloadImage$1(url) {
 	if (url.startsWith("data:image/")) {
 		const base64Data = url.split(",")[1];
@@ -11793,8 +14156,15 @@ async function processAndStoreImages(images, context) {
 	return Promise.all(images.map(async (image) => {
 		const buffer = await downloadImage$1(image);
 		const fileType = await fileTypeFromBuffer(buffer);
-		const filename = `${v4()}.${fileType?.ext}`;
-		return await context.imageGenerateStorage.upload(buffer, filename, {});
+		const ext = fileType?.ext ?? "png";
+		const filename = `${v4()}.${ext}`;
+		const path = await context.imageGenerateStorage.upload(buffer, filename, {});
+		await persistGeneratedFileAsFabFile(context, {
+			fileName: `generated-image-${filename.slice(0, 8)}.${ext}`,
+			mimeType: fileType?.mime ?? "image/png",
+			content: buffer
+		});
+		return path;
 	}));
 }
 async function updateQuestAndReturnMarkdown$1(storedImageUrls, context) {
@@ -15278,13 +17648,13 @@ const knowledgeBaseRetrieveTool = {
 function formatResult$1(result) {
 	const lines = [
 		`Solver: ${result.solverName} (${result.solverId})`,
-		`Makespan: ${result.makespan}`,
+		`Makespan: ${result.objective}`,
 		`Elapsed: ${result.elapsedMs.toFixed(1)}ms`
 	];
 	if (result.iterations !== void 0) lines.push(`Iterations: ${result.iterations}`);
 	lines.push("Schedule:");
 	const byMachine = /* @__PURE__ */ new Map();
-	for (const op of result.schedule) {
+	for (const op of result.solution) {
 		if (!byMachine.has(op.machineId)) byMachine.set(op.machineId, []);
 		byMachine.get(op.machineId).push(op);
 	}
@@ -15321,13 +17691,13 @@ async function runQuantumSchedule(params) {
 		}
 	}
 	if (results.length === 0) return `Error: No solvers completed successfully.\n${errors.join("\n")}`;
-	results.sort((a, b) => a.makespan - b.makespan);
+	results.sort((a, b) => a.objective - b.objective);
 	const lines = [];
 	lines.push(`## Scheduling Results for "${problem.name}"`);
 	lines.push(`Problem: ${problem.jobs.length} jobs, ${problem.machines.length} machines, ${problem.jobs.reduce((s, j) => s + j.operations.length, 0)} operations`);
 	lines.push("");
 	if (results.length > 1) {
-		lines.push(`### Winner: ${results[0].solverName} (makespan: ${results[0].makespan})`);
+		lines.push(`### Winner: ${results[0].solverName} (makespan: ${results[0].objective})`);
 		lines.push("");
 	}
 	for (const result of results) {
@@ -15444,37 +17814,92 @@ The problem must define jobs (each with ordered operations) and machines. Each o
 		}
 	})
 };
+const FAMILY_IDS = [
+	"routing",
+	"packing",
+	"assignment",
+	"network",
+	"partitioning",
+	"selection",
+	"economic",
+	"continuous"
+];
+/** Run the model and pull a JSON object out of the response (handles code fences). */
+async function completeToJson(context, systemPrompt, userDescription) {
+	let rawContent = "";
+	await context.llm.complete(context.model ?? "gpt-4", [{
+		role: "system",
+		content: systemPrompt
+	}, {
+		role: "user",
+		content: userDescription
+	}], {
+		temperature: .2,
+		stream: false
+	}, async (texts) => {
+		rawContent = texts.filter((t) => t !== null && t !== void 0).join("");
+	});
+	let jsonStr = rawContent.trim();
+	const codeBlockMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+	if (codeBlockMatch) jsonStr = codeBlockMatch[1].trim();
+	try {
+		return { json: JSON.parse(jsonStr) };
+	} catch {
+		return { error: `Could not parse the model response as JSON. Raw response:\n${rawContent}` };
+	}
+}
+/** Build the per-family system prompt from a real sample as the shape template. */
+function familyFormulationPrompt(familyId) {
+	return `You convert a natural-language description into a "${familyId}" optimization problem as JSON.
+
+Output ONLY a single JSON object matching this exact shape (a real ${familyId} example):
+
+${JSON.stringify(FAMILY_SAMPLE_PROBLEMS[familyId][0], null, 2)}
+
+Rules:
+- "family" MUST be exactly "${familyId}".
+- Keep it small and browser-solvable, at a scale similar to the example.
+- ids are integers starting at 0; names are short human-readable strings.
+- Output ONLY the JSON object — no prose, no markdown fences.`;
+}
 const quantumFormulateTool = {
 	name: "quantum_formulate",
 	implementation: (context) => ({
 		toolFn: async (value) => {
-			const userDescription = value.description?.trim();
-			if (!userDescription) return "Error: Please provide a description of the scheduling problem to formulate.";
+			const params = value;
+			const userDescription = params.description?.trim();
+			if (!userDescription) return "Error: Please provide a description of the optimization problem to formulate.";
+			if (params.familyId && !FAMILY_IDS.includes(params.familyId)) return `Error: unknown familyId "${String(params.familyId)}". Valid families: ${FAMILY_IDS.join(", ")}. Omit familyId to formulate a job-shop scheduling problem.`;
+			const familyId = params.familyId || void 0;
 			try {
-				let rawContent = "";
-				await context.llm.complete(context.model ?? "gpt-4", [{
-					role: "system",
-					content: PROBLEM_FORMULATION_PROMPT
-				}, {
-					role: "user",
-					content: userDescription
-				}], {
-					temperature: .2,
-					stream: false
-				}, async (texts) => {
-					rawContent = texts.filter((t) => t !== null && t !== void 0).join("");
-				});
-				let jsonStr = rawContent.trim();
-				const codeBlockMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
-				if (codeBlockMatch) jsonStr = codeBlockMatch[1].trim();
-				let parsed;
-				try {
-					parsed = JSON.parse(jsonStr);
-				} catch {
-					return `Error: Could not parse LLM response as JSON. Raw response:\n${rawContent}\n\nPlease try rephrasing your description with more specific details about jobs, machines, and processing times.`;
+				if (familyId) {
+					const result = await completeToJson(context, familyFormulationPrompt(familyId), userDescription);
+					if ("error" in result) return `Error: ${result.error}\n\nPlease rephrase with more specifics for a ${familyId} problem.`;
+					const validated = FAMILY_PROBLEM_SCHEMAS[familyId].safeParse(result.json);
+					if (!validated.success) return `Error: the model produced an invalid ${familyId} problem.\n${validated.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}\n\nPlease rephrase your description.`;
+					const problem = validated.data;
+					const summary = [
+						`## Formulated: "${problem.name}"`,
+						problem.description ? `\n${problem.description}` : "",
+						"",
+						`**${familyId} problem** — ready to load.`,
+						"",
+						`Open the ${familyId} console's Problem tab and click "Load problem" on the pending banner to review, tweak, and race solvers.`
+					].filter((l) => l !== void 0).join("\n");
+					return JSON.stringify({
+						__uiSideEffect: true,
+						type: "populateFamilyProblem",
+						payload: {
+							familyId,
+							problem
+						},
+						displayMessage: summary
+					});
 				}
-				const validated = SchedulingProblemSchema.safeParse(parsed);
-				if (!validated.success) return `Error: LLM generated an invalid problem structure.\n${validated.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}\n\nRaw output:\n${jsonStr}\n\nPlease try rephrasing your description.`;
+				const result = await completeToJson(context, PROBLEM_FORMULATION_PROMPT, userDescription);
+				if ("error" in result) return `Error: ${result.error}\n\nPlease try rephrasing with specific jobs, machines, and processing times.`;
+				const validated = SchedulingProblemSchema.safeParse(result.json);
+				if (!validated.success) return `Error: LLM generated an invalid problem structure.\n${validated.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}\n\nPlease try rephrasing your description.`;
 				const problem = validated.data;
 				const totalOps = problem.jobs.reduce((s, j) => s + j.operations.length, 0);
 				const humanReadableSummary = [
@@ -15509,21 +17934,28 @@ const quantumFormulateTool = {
 		},
 		toolSchema: {
 			name: "quantum_formulate",
-			description: `Convert a natural language description of a scheduling/optimization problem into a structured SchedulingProblem that can be solved by the quantum_schedule tool.
+			description: `Convert a natural-language description of an optimization problem into a structured problem that the /opti solvers can run.
 
-Describe the problem in plain English — what jobs need to be done, what machines or resources are available, how long each step takes, and any ordering constraints. The tool will produce a structured problem definition.
+Pass \`familyId\` to target one of the eight pattern families; omit it for job-shop scheduling:
+- routing (TSP / vehicle routing), packing (bin packing), assignment (who does what),
+  network (max-cut), partitioning (balanced k-way), selection (knapsack / portfolio),
+  economic (combinatorial auction), continuous (function minimization).
 
-Examples:
-- "I have 3 orders to manufacture. Each needs cutting, welding, and painting. Cutting takes 2h, welding 3h, painting 1h."
-- "Schedule 4 software builds across 2 CI runners. Build A needs compile (5min) then test (3min)..."
-- "A bakery needs to make 5 cakes. Each cake goes through mixing, baking, and decorating on separate stations."`,
-			strict: true,
+Describe the scenario in plain English — the entities, resources, costs/values, and constraints — and the tool produces a structured problem definition for that family.`,
+			strict: false,
 			parameters: {
 				type: "object",
-				properties: { description: {
-					type: "string",
-					description: "Natural language description of the scheduling problem to formulate"
-				} },
+				properties: {
+					description: {
+						type: "string",
+						description: "Natural-language description of the optimization problem to formulate"
+					},
+					familyId: {
+						type: "string",
+						enum: FAMILY_IDS,
+						description: "Optional optimization family. Omit for job-shop scheduling; otherwise one of the eight families."
+					}
+				},
 				required: ["description"],
 				additionalProperties: false
 			}
@@ -15837,6 +18269,7 @@ Please generate a complete, well-structured notebook that performs this analysis
 		}
 	})
 };
+const XLSX_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
 const LIMITS = {
 	MAX_SHEETS: 10,
 	MAX_CELLS_PER_SHEET: 1e4,
@@ -16155,9 +18588,14 @@ const excelGenerationTool = {
 				const sanitizedName = sanitizeFilename(params.filename);
 				const filename = `${sanitizedName}-${v4().slice(0, 8)}.xlsx`;
 				await context.imageGenerateStorage.upload(buffer, filename, {
-					ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+					ContentType: XLSX_MIME,
 					ContentDisposition: `attachment; filename="${sanitizedName}.xlsx"`
 				});
+				await persistGeneratedFileAsFabFile(context, {
+					fileName: `${sanitizedName}.xlsx`,
+					mimeType: XLSX_MIME,
+					content: buffer
+				});
 				await context.onFinish?.("excel_generation", [filename]);
 				await context.statusUpdate({ images: [filename] });
 				return `Successfully generated Excel file: ${sanitizedName}.xlsx`;
@@ -17443,10 +19881,11 @@ const b4mTools = {
 	fmp_financial_data: fmpTool,
 	skill: skillTool
 };
-const generateTools = (userId, user, logger, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, imageProcessorLambdaName, tools = b4mTools, allowedDirectories, entitlementKeys = []) => {
+const generateTools = (userId, user, logger, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, imageProcessorLambdaName, tools = b4mTools, allowedDirectories, entitlementKeys = [], sessionId) => {
 	const context = {
 		userId,
 		user,
+		sessionId,
 		logger,
 		db,
 		storage,
@@ -18467,7 +20906,11 @@ var ReActAgent = class extends EventEmitter {
 	* This can be overridden in the context or customized here
 	*/
 	getSystemPrompt() {
-		if (this.context.systemPrompt) return this.context.systemPrompt;
+		const base = this.context.systemPrompt ? this.context.systemPrompt : this.buildDefaultSystemPrompt();
+		const persona = this.context.personaPrompt?.trim();
+		return persona ? `${persona}\n\n${base}` : base;
+	}
+	buildDefaultSystemPrompt() {
 		return `You are an autonomous AI agent with access to tools. Your job is to solve problems by taking action, not by asking for clarification.
 
 CORE PRINCIPLES:
@@ -19090,7 +21533,7 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
 					})}</function>`;
 				}
 			}
-			return `Error: Tool ${toolUse.name} not found in agent context`;
+			return `Error: Tool "${toolUse.name}" is not available in this context and cannot be called. Do NOT attempt to call it again. Proceed without it — call other available tools if your plan still needs them, or compose your final answer from the information already gathered if no more tools are needed.`;
 		}
 		try {
 			const params = this.parseToolArguments(toolUse.arguments);
@@ -20458,33 +22901,6 @@ z.object({
 	fabFileId: z.string(),
 	chunkId: z.string()
 });
-z.object({
-	fileName: z.string(),
-	mimeType: z.string(),
-	fileSize: z.number(),
-	type: z.enum(KnowledgeType),
-	content: z.union([z.string(), z.instanceof(Buffer)]).optional(),
-	organizationId: z.string().optional(),
-	/**
-	* Content type of the file
-	* @example 'text/markdown'
-	* @example 'application/pdf'
-	* @example 'application/octet-stream' for binary files
-	*/
-	contentType: z.string().optional(),
-	public: z.boolean().optional(),
-	prefix: z.string().optional(),
-	system: z.boolean().optional(),
-	tags: z.array(z.object({
-		name: z.string(),
-		strength: z.number()
-	})).optional(),
-	systemPriority: z.number().optional(),
-	sessionId: z.string().optional(),
-	contentHash: z.string().optional(),
-	batchId: z.string().optional(),
-	relativePath: z.string().optional()
-});
 z.object({ sessionId: z.string() });
 z.object({ questId: z.string() });
 z.object({ url: z.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/) });