@bike4mind/cli 0.18.0 → 0.18.2

package/dist/{BackgroundAgentManager-ChmoEU9H.mjs → BackgroundAgentManager-d_iU7ati.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-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-yJU1dxpP.mjs";
+import { $ as PermissionDeniedError, $t as wrapUntrustedSkillBody, A as FriendshipEvents, At as XAI_IMAGE_MODELS, B as InboxEvents, Bt as isSupportedEmbeddingModel, 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 resolveNavigationIntents, H as InviteEvents, Ht as mapMimeTypeToArtifactType, I as HttpStatus, It as intersectAllowedTools, J as ModelBackend, Jt as settingsMap, K as MiscEvents, Kt as sanitizeTelemetryError, L as ImageEditUsageTransaction, Lt as isGPTImage2Model, 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, R as ImageGenerationUsageTransaction, Rt as isGPTImageModel, S as CompletionApiUsageTransaction, St as ToolUsageTransaction, T as ElabsEvents, Tt as UnauthorizedError, U as InviteType, Ut as obfuscateApiKey, V as InternalServerError, Vt as isZodError, W as KnowledgeType, Wt as parseSkillArguments, X as OpenAIEmbeddingModel, Xt as toDataLakeConfig, Y as NotFoundError, Yt as substituteArguments$1, 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 buildRateLimitLogEntry, 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, in as CollectionType, 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 isNearLimit, nt as PromptIntentSchema, ot as RealtimeVoiceUsageTransaction, p as ArtifactTypeSchema, pt as ResearchTaskType, q as ModalEvents, qt as secureParameters, rn as parseRateLimitHeaders, rt as PromptMetaZodSchema, s as ALERT_THRESHOLDS, st as ReceivedCreditTransaction, t as ConfigStore, tn as extractSnippetMeta, 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 isModelAccessible } from "./ConfigStore-DL7p3ZiY.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-B3f78bSl.mjs";
+import { t as version } from "./package-WpJJMKy_.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";
@@ -7086,7 +7086,9 @@ function shouldTriggerFallback(error) {
 		"api key",
 		"quota exceeded",
 		"model not found",
-		"does not exist"
+		"does not exist",
+		"is not available",
+		"safety classifier refusal"
 	].some((trigger) => message.includes(trigger));
 }
 /**
@@ -7149,17 +7151,20 @@ function findAutomaticFallback(originalModel, availableModels, apiKeyTable, logg
 			"claude-opus-4-8",
 			"claude-opus-4-7",
 			"claude-opus-4-6",
+			"claude-sonnet-5",
 			"claude-sonnet-4-6",
 			"gpt-5"
 		],
 		"claude-opus-4-8": [
 			"claude-opus-4-7",
 			"claude-opus-4-6",
+			"claude-sonnet-5",
 			"claude-sonnet-4-6",
 			"gpt-5"
 		],
 		"claude-opus-4-7": [
 			"claude-opus-4-6",
+			"claude-sonnet-5",
 			"claude-sonnet-4-6",
 			"gpt-5"
 		],
@@ -7170,17 +7175,26 @@ function findAutomaticFallback(originalModel, availableModels, apiKeyTable, logg
 			"claude-haiku-4-5-20251001"
 		],
 		"claude-opus-4-6": [
+			"claude-sonnet-5",
 			"claude-sonnet-4-6",
 			"claude-sonnet-4-5-20250929",
 			"gpt-5",
 			"claude-haiku-4-5-20251001"
 		],
+		"claude-sonnet-5": [
+			"claude-sonnet-4-6",
+			"claude-sonnet-4-5-20250929",
+			"gpt-5"
+		],
+		"global.anthropic.claude-sonnet-5": ["global.anthropic.claude-sonnet-4-6", "gpt-5"],
 		"claude-sonnet-4-6": [
+			"claude-sonnet-5",
 			"claude-sonnet-4-5-20250929",
 			"claude-opus-4-5-20251101",
 			"gpt-5"
 		],
 		"claude-sonnet-4-5-20250929": [
+			"claude-sonnet-5",
 			"claude-sonnet-4-6",
 			"claude-haiku-4-5-20251001",
 			"gpt-5"
@@ -7212,7 +7226,7 @@ function findAutomaticFallback(originalModel, availableModels, apiKeyTable, logg
 		],
 		"gpt-4o-mini": ["claude-haiku-4-5-20251001", "gpt-3.5-turbo"]
 	}[originalModel.id] || [];
-	if (preferences.length === 0) preferences.push("claude-sonnet-4-6", "claude-sonnet-4-5-20250929", "gpt-5", "claude-haiku-4-5-20251001");
+	if (preferences.length === 0) preferences.push("claude-sonnet-5", "claude-sonnet-4-6", "claude-sonnet-4-5-20250929", "gpt-5", "claude-haiku-4-5-20251001");
 	for (const modelId of preferences) {
 		const fallbackModel = availableModels.find((m) => m.id === modelId);
 		if (fallbackModel) {
@@ -7869,7 +7883,7 @@ function classifyError(error) {
 	return "unhandled_rejection";
 }
 /**
-* Builds a structured log entry for Lambda error handlers.
+* Builds a structured log entry for the global error handlers.
 */
 function buildLogEntry(error, category) {
 	return {
@@ -7884,29 +7898,33 @@ function buildLogEntry(error, category) {
 /**
 * Registers global handlers for unhandled promise rejections and uncaught exceptions.
 *
-* IMPORTANT: This is for OBSERVABILITY ONLY. AWS Lambda's default handlers will still
-* cause the invocation to fail. These handlers allow us to:
-* 1. Log errors with structured context before Lambda exits
+* Provider-agnostic core shared by Lambda handlers and the always-on
+* QuestProcessorService container. The handlers:
+* 1. Log errors with structured context
 * 2. Classify error types for easier debugging
-* 3. Distinguish network errors from application errors
+* 3. Distinguish network errors from application errors and swallow the network
+*    class (mark the rejection handled / don't re-throw) so a single transient
+*    network failure doesn't escalate
 *
-* DO NOT call process.exit() - let Lambda manage the lifecycle.
+* CRITICAL for long-running processes: these handlers NEVER call process.exit().
+* On AWS Lambda that lets the runtime own the lifecycle. On a long-running Fargate
+* task it means one quest's mid-stream EPIPE / orphaned undici rejection (#8055,
+* #8197) is logged and swallowed instead of taking Node's default
+* `uncaughtException` path, which would terminate the whole container and kill
+* every other in-flight quest.
 *
 * @param logger - Optional logger instance. Falls back to console if not provided.
+* @param context - Short label used in log message prefixes (default 'Process').
 *
 * @example
 * ```typescript
-* import { registerLambdaErrorHandlers } from '@bike4mind/utils';
+* import { registerProcessErrorHandlers } from '@bike4mind/utils';
 *
-* // Call at the top of your Lambda handler file (after imports)
-* registerLambdaErrorHandlers();
-*
-* export const handler = async (event) => {
-*   // Your handler code
-* };
+* // Call once at startup, after imports
+* registerProcessErrorHandlers(logger, 'QuestProcessorService');
 * ```
 */
-function registerLambdaErrorHandlers(logger) {
+function registerProcessErrorHandlers(logger, context = "Process") {
 	if (isRegistered) return;
 	isRegistered = true;
 	const log = logger || console;
@@ -7915,17 +7933,27 @@ function registerLambdaErrorHandlers(logger) {
 		const isNetworkError = category.startsWith("network_");
 		const logEntry = buildLogEntry(reason, category);
 		if (isNetworkError) {
-			log.warn("[Lambda] Network error (unhandled rejection)", logEntry);
+			log.warn(`[${context}] Network error (unhandled rejection)`, logEntry);
 			promise.catch(() => {});
-		} else log.error("[Lambda] Unhandled promise rejection", logEntry);
+		} else log.error(`[${context}] Unhandled promise rejection`, logEntry);
 	});
 	process.on("uncaughtException", (error) => {
 		const category = classifyError(error);
-		if (category.startsWith("network_")) log.warn("[Lambda] Network error (uncaught exception)", buildLogEntry(error, category));
-		else log.error("[Lambda] Uncaught exception", buildLogEntry(error, "uncaught_exception"));
+		if (category.startsWith("network_")) log.warn(`[${context}] Network error (uncaught exception)`, buildLogEntry(error, category));
+		else log.error(`[${context}] Uncaught exception`, buildLogEntry(error, "uncaught_exception"));
 	});
 }
 /**
+* Back-compat alias for Lambda handlers. Preserves the historical `[Lambda]` log
+* prefix so existing log-based filters/alerts are unaffected. New code on
+* non-Lambda runtimes should call {@link registerProcessErrorHandlers} directly.
+*
+* @param logger - Optional logger instance. Falls back to console if not provided.
+*/
+function registerLambdaErrorHandlers(logger) {
+	registerProcessErrorHandlers(logger, "Lambda");
+}
+/**
 * Reset the registration state. Only for testing purposes.
 * @internal
 */
@@ -8055,6 +8083,7 @@ __reExport(/* @__PURE__ */ __exportAll$1({
 	processFabFilesServer: () => processFabFilesServer,
 	processUrlsFromPrompt: () => processUrlsFromPrompt,
 	registerLambdaErrorHandlers: () => registerLambdaErrorHandlers,
+	registerProcessErrorHandlers: () => registerProcessErrorHandlers,
 	secureParameters: () => secureParameters,
 	sendToConnection: () => sendToConnection,
 	shouldTriggerFallback: () => shouldTriggerFallback,
@@ -8876,22 +8905,22 @@ function makeSchedulingResult(args) {
 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([
@@ -8955,13 +8984,18 @@ const greedySolver = {
 				totalIterations: totalOps
 			});
 		}
+		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
+			}]
 		});
 	}
 };
@@ -9092,6 +9126,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) {
@@ -9127,19 +9189,25 @@ 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({
@@ -9163,7 +9231,8 @@ const naiveSolver = {
 			makespan: bestMakespan,
 			schedule: bestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: count
+			iterations: count,
+			trace
 		});
 	}
 };
@@ -9188,18 +9257,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);
@@ -9213,6 +9286,7 @@ const randomRestartSolver = {
 			if (currentMakespan < globalBestMakespan) {
 				globalBestMakespan = currentMakespan;
 				globalBestSchedule = currentSchedule;
+				pushScheduleTrace(trace, globalBestSchedule, globalBestMakespan);
 			}
 			options?.onProgress?.({
 				solverId: "random-restart",
@@ -9228,7 +9302,8 @@ const randomRestartSolver = {
 			makespan: globalBestMakespan,
 			schedule: globalBestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: totalIterations
+			iterations: totalIterations,
+			trace
 		});
 	}
 };
@@ -9265,17 +9340,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);
@@ -9287,6 +9366,7 @@ function createSASolver(config) {
 					if (currentMakespan < bestMakespan) {
 						bestSchedule = currentSchedule;
 						bestMakespan = currentMakespan;
+						pushScheduleTrace(trace, bestSchedule, bestMakespan);
 					}
 				}
 				temperature *= config.coolingRate;
@@ -9311,7 +9391,8 @@ function createSASolver(config) {
 				makespan: bestMakespan,
 				schedule: bestSchedule,
 				elapsedMs: performance.now() - startTime,
-				iterations: config.iterations
+				iterations: config.iterations,
+				trace
 			});
 		}
 	};
@@ -9326,7 +9407,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 = {
@@ -9335,17 +9416,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 = "";
@@ -9371,6 +9456,7 @@ const tabuSolver = {
 				if (currentMakespan < bestMakespan) {
 					bestMakespan = currentMakespan;
 					bestSchedule = currentSchedule;
+					pushScheduleTrace(trace, bestSchedule, bestMakespan);
 				}
 			}
 			if (iter % 100 === 0) {
@@ -9378,18 +9464,18 @@ const tabuSolver = {
 			}
 			if (options?.onProgress && iter % progressInterval === 0) options.onProgress({
 				solverId: "tabu",
-				percentage: Math.round(iter / ITERATIONS$1 * 100),
+				percentage: Math.round(iter / ITERATIONS$2 * 100),
 				bestObjective: bestMakespan,
 				currentIteration: iter,
-				totalIterations: ITERATIONS$1
+				totalIterations: ITERATIONS$2
 			});
 		}
 		options?.onProgress?.({
 			solverId: "tabu",
 			percentage: 100,
 			bestObjective: bestMakespan,
-			currentIteration: ITERATIONS$1,
-			totalIterations: ITERATIONS$1
+			currentIteration: ITERATIONS$2,
+			totalIterations: ITERATIONS$2
 		});
 		return makeSchedulingResult({
 			solverId: "tabu",
@@ -9397,7 +9483,8 @@ const tabuSolver = {
 			makespan: bestMakespan,
 			schedule: bestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: ITERATIONS$1
+			iterations: ITERATIONS$2,
+			trace
 		});
 	}
 };
@@ -9417,7 +9504,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++) {
@@ -9429,8 +9516,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) {
@@ -9446,7 +9537,10 @@ 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),
@@ -9462,7 +9556,8 @@ const geneticAlgorithmSolver = {
 			makespan: bestIndividual.makespan,
 			schedule: bestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: GENERATIONS * POPULATION_SIZE
+			iterations: GENERATIONS * POPULATION_SIZE,
+			trace
 		});
 	}
 };
@@ -9507,10 +9602,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",
@@ -9518,7 +9613,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;
@@ -9526,10 +9621,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);
@@ -9542,9 +9641,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++) {
@@ -9554,10 +9654,10 @@ const antColonySolver = {
 			}
 			options?.onProgress?.({
 				solverId: "ant-colony",
-				percentage: Math.round((iter + 1) / ITERATIONS * 100),
+				percentage: Math.round((iter + 1) / ITERATIONS$1 * 100),
 				bestObjective: bestMakespan,
 				currentIteration: iter + 1,
-				totalIterations: ITERATIONS
+				totalIterations: ITERATIONS$1
 			});
 		}
 		return makeSchedulingResult({
@@ -9566,7 +9666,8 @@ const antColonySolver = {
 			makespan: bestMakespan,
 			schedule: bestSchedule,
 			elapsedMs: performance.now() - startTime,
-			iterations: ITERATIONS * NUM_ANTS
+			iterations: ITERATIONS$1 * NUM_ANTS,
+			trace
 		});
 	}
 };
@@ -9813,23 +9914,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;
 }
@@ -9861,6 +9957,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, {
@@ -9899,7 +10010,11 @@ const highsSolver = {
 				makespan,
 				schedule,
 				elapsedMs: elapsed(startTime),
-				iterations: 1
+				iterations: 1,
+				trace: [{
+					solution: schedule,
+					objective: makespan
+				}]
 			});
 		} catch (error) {
 			reportProgress(0);
@@ -10544,31 +10659,39 @@ const allSolvers = [
 				solverId: "qaoa-local",
 				percentage: pct
 			});
+			const cancelled = () => options.shouldCancel?.() ?? false;
 			progress(0);
 			const greedyResult = await greedySolver.solve(problem, {});
 			progress(10);
 			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 makeSchedulingResult({
-					solverId: "qaoa-local",
-					solverName: "QAOA (Local)",
-					makespan: greedyMakespan,
-					schedule: greedySchedule,
-					elapsedMs: elapsed(),
-					metadata: {
-						layers: LAYERS$1,
-						shots: 0,
-						gamma: 0,
-						beta: 0,
-						rawMakespan: greedyMakespan,
-						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);
@@ -10578,6 +10701,7 @@ 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);
@@ -10594,6 +10718,13 @@ const allSolvers = [
 				makespan: winnerMakespan,
 				schedule: winnerSchedule,
 				elapsedMs: elapsed(),
+				trace: [{
+					solution: greedySchedule,
+					objective: greedyMakespan
+				}, {
+					solution: winnerSchedule,
+					objective: winnerMakespan
+				}],
 				metadata: {
 					layers: LAYERS$1,
 					shots: FINAL_SHOTS$1,
@@ -10636,11 +10767,12 @@ RULES:
 5. Each machine can only process one operation at a time
 6. Assign reasonable durations if not specified (use whole numbers)
 7. Create meaningful names for jobs and machines based on context
+8. "description" MUST be a single plain-English sentence summarizing the real-world scenario this models (what the user just described) — it is shown on the on-screen brief card so a human can recognize at a glance that it matches the conversation. e.g. "Scheduling the 6 high-priority sprint issues across 5 developers to minimize total completion time."
 
 RESPOND WITH ONLY A JSON OBJECT matching this schema:
 {
-  "name": "string - descriptive problem name",
-  "description": "string - brief description",
+  "name": "string - short descriptive problem name",
+  "description": "string - one plain-English sentence summarizing the scenario (see rule 8)",
   "jobs": [
     {
       "id": 0,
@@ -10901,54 +11033,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 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 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
+			}
+		]
 	}
-	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,
+];
+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
 }));
-plate.nodes, plate.edges, reservoir.nodes, reservoir.edges, blade.nodes, blade.edges;
+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 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)"]
+	}
+];
 var QuboBuilder = class {
 	size;
 	q = /* @__PURE__ */ new Map();
@@ -11280,8 +13324,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-B2RLL9dT.mjs
+//#region ../../b4m-core/services/dist/tools-D9uncH3M.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;
@@ -11642,18 +13948,22 @@ 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;
+	const userId = context.user.id ? String(context.user.id) : 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, userId)).map(toDataLakeConfig);
 	} catch {}
 	const accessibleLakes = getAccessibleDataLakes(userTags, dynamicDataLakes, entitlementKeys);
+	const dynamicIds = new Set((dynamicDataLakes ?? []).map((d) => d.id));
 	return {
 		dataLakeTags: accessibleLakes.map((dl) => dl.datalakeTag),
-		dataLakeTagPrefixes: accessibleLakes.map((dl) => dl.fileTagPrefix)
+		dataLakeTagPrefixes: accessibleLakes.filter((dl) => !dynamicIds.has(dl.id)).map((dl) => dl.fileTagPrefix),
+		scopedTagPrefixes: accessibleLakes.filter((dl) => dynamicIds.has(dl.id)).map((dl) => dl.fileTagPrefix)
 	};
 }
 async function semanticDataLakeSearch(params, adapters) {
-	const { userId, userGroups = [], query, tags = [], topK = 10, minScore = 0, embeddingModel, apiKeyTable, dataLakeTags, dataLakeTagPrefixes, maxFiles = 2e3, chunkLoadCap = 1e4, logger } = params;
+	const { userId, userGroups = [], query, tags = [], topK = 10, minScore = 0, embeddingModel, apiKeyTable, dataLakeTags, dataLakeTagPrefixes, scopedTagPrefixes = [], maxFiles = 2e3, chunkLoadCap = 1e4, logger } = params;
 	const empty = {
 		results: [],
 		totalChunksSearched: 0,
@@ -11687,6 +13997,7 @@ async function semanticDataLakeSearch(params, adapters) {
 		userGroups,
 		dataLakeTags,
 		dataLakeTagPrefixes,
+		scopedTagPrefixes,
 		excludeContent: true
 	});
 	const fileIds = fileSearch.data.map((f) => f.id);
@@ -11792,6 +14103,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];
@@ -11825,8 +14190,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) {
@@ -12538,7 +14910,7 @@ const currentDateTimeTool = {
 		},
 		toolSchema: {
 			name: "current_datetime",
-			description: "Get the current date and time with advanced features. Supports multiple output formats, date calculations (days until/since), historical day lookups, and IANA timezone identifiers.",
+			description: "Get the current, real-world date and time, fresh at the moment of the call. Call this whenever you need the current time of day (hour/minute) or to timestamp an action as it executes — never guess or rely on memory. Supports multiple output formats, date calculations (days until/since), historical day lookups, and IANA timezone identifiers.",
 			parameters: {
 				type: "object",
 				properties: {
@@ -14957,7 +17329,7 @@ async function trySemanticKbSearch(context, query, tags, maxResults) {
 		const provider = getProviderFromModel(embeddingModel);
 		if (provider === "openai" && !apiKeyTable?.openai) return null;
 		if (provider === "voyageai" && !apiKeyTable?.voyageai) return null;
-		const { dataLakeTags, dataLakeTagPrefixes } = await getDynamicDataLakeAccess(context);
+		const { dataLakeTags, dataLakeTagPrefixes, scopedTagPrefixes } = await getDynamicDataLakeAccess(context);
 		if (dataLakeTags.length === 0) return null;
 		const search = await semanticDataLakeSearch({
 			userId: context.userId,
@@ -14970,6 +17342,7 @@ async function trySemanticKbSearch(context, query, tags, maxResults) {
 			apiKeyTable,
 			dataLakeTags,
 			dataLakeTagPrefixes,
+			scopedTagPrefixes,
 			logger: context.logger
 		}, { db: {
 			fabfiles: context.db.fabfiles,
@@ -15043,7 +17416,7 @@ const knowledgeBaseSearchTool = {
 				const semantic = await trySemanticKbSearch(context, query, tags, max_results);
 				if (semantic) return semantic;
 				try {
-					const { dataLakeTags, dataLakeTagPrefixes } = await getDynamicDataLakeAccess(context);
+					const { dataLakeTags, dataLakeTagPrefixes, scopedTagPrefixes } = await getDynamicDataLakeAccess(context);
 					const searchResults = await context.db.fabfiles.search(context.userId, query, {
 						tags: tags || [],
 						type: file_type,
@@ -15060,6 +17433,7 @@ const knowledgeBaseSearchTool = {
 						userGroups: context.user.groups || [],
 						dataLakeTags,
 						dataLakeTagPrefixes,
+						scopedTagPrefixes,
 						excludeContent: true
 					});
 					const queryTerms = Array.from(new Set(query.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 3)));
@@ -15207,7 +17581,7 @@ const knowledgeBaseRetrieveTool = {
 						if (files.length === 0) return `No document found with ID "${file_id}". The file may not exist or you may not have access to it. Try using search_knowledge_base to find the correct file ID.`;
 					}
 					if (files.length === 0 && (tags?.length || query)) {
-						const { dataLakeTags, dataLakeTagPrefixes } = await getDynamicDataLakeAccess(context);
+						const { dataLakeTags, dataLakeTagPrefixes, scopedTagPrefixes } = await getDynamicDataLakeAccess(context);
 						files = (await context.db.fabfiles.search(context.userId, query || "", {
 							tags: tags || [],
 							shared: false
@@ -15223,6 +17597,7 @@ const knowledgeBaseRetrieveTool = {
 							userGroups: context.user.groups || [],
 							dataLakeTags,
 							dataLakeTagPrefixes,
+							scopedTagPrefixes,
 							excludeContent: true
 						})).data;
 						if (files.length === 0) return `No documents found matching ${[query && `query "${query}"`, tags?.length && `tags [${tags.join(", ")}]`].filter(Boolean).join(" and ")}. Try broadening your search with search_knowledge_base.`;
@@ -15326,6 +17701,13 @@ function formatResult$1(result) {
 	}
 	return lines.join("\n");
 }
+/**
+* Returns a JSON `{ __uiSideEffect: true, ... }` envelope (see end of function), NOT
+* model-facing text. Production exec routes this through `wrapToolsForSentinels`
+* (sharedToolBuilder), which strips the envelope and surfaces `displayMessage` to the
+* model. Any future exec path that bypasses `wrapToolsForSentinels` would leak the raw
+* envelope into the model context — keep it behind that wrapper.
+*/
 async function runQuantumSchedule(params) {
 	const parseResult = SchedulingProblemSchema.safeParse(params.problem);
 	if (!parseResult.success) return `Error: Invalid scheduling problem format.\n${parseResult.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}\n\nExpected format: { name, jobs: [{ id, name, operations: [{ jobId, machineId, duration }] }], machines: [{ id, name }] }`;
@@ -15371,7 +17753,12 @@ async function runQuantumSchedule(params) {
 		lines.push("### Errors");
 		errors.forEach((e) => lines.push(`- ${e}`));
 	}
-	return lines.join("\n");
+	return JSON.stringify({
+		__uiSideEffect: true,
+		type: "populateProblem",
+		payload: problem,
+		displayMessage: lines.join("\n")
+	});
 }
 const quantumScheduleTool = {
 	name: "quantum_schedule",
@@ -15385,7 +17772,9 @@ Available solvers: ${allSolvers.map((s) => `${s.id} (${s.name})`).join(", ")}.
 
 The "greedy" solver runs instantly. Metaheuristic solvers (simulated-annealing, tabu, genetic-algorithm, ant-colony) explore larger solution spaces but take longer. Use multiple solvers to race them against each other.
 
-The problem must define jobs (each with ordered operations) and machines. Each operation runs on a specific machine for a specific duration. Operations within a job must run in order.`,
+The problem must define jobs (each with ordered operations) and machines. Each operation runs on a specific machine for a specific duration. Operations within a job must run in order.
+
+Calling this loads the problem into the on-screen /opti Scheduling console (brief + Problem tab) so the user sees exactly what was solved and can tweak and re-race it — so the screen always matches the conversation.`,
 			parameters: {
 				type: "object",
 				properties: {
@@ -15476,37 +17865,93 @@ The problem must define jobs (each with ordered operations) and machines. Each o
 		}
 	})
 };
+const FAMILY_IDS$1 = [
+	"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$1(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.
+- "description" MUST be a single plain-English sentence summarizing the real-world scenario this models (what the user just described) — it is shown on the on-screen brief card so a human can recognize at a glance that it matches the conversation.
+- 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$1.includes(params.familyId)) return `Error: unknown familyId "${String(params.familyId)}". Valid families: ${FAMILY_IDS$1.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$1(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** — loaded into your active brief.`,
+						"",
+						`I've opened the ${familyId} console and set this as the active brief (use Undo on the banner to revert). Tweak it on the Problem tab or open Solvers to race it.`
+					].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$1(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 = [
@@ -15527,7 +17972,7 @@ const quantumFormulateTool = {
 					"### Machines:",
 					...problem.machines.map((m) => `- ${m.name} (id: ${m.id})`),
 					"",
-					"A problem is ready to load. Navigate to the Problem tab and click \"Load Problem\" to review, tweak, and run solvers."
+					"I've loaded this as your active scheduling brief (use Undo on the banner to revert). Tweak it on the Problem tab or open Solvers to race it."
 				].filter((l) => l !== void 0).join("\n");
 				return JSON.stringify({
 					__uiSideEffect: true,
@@ -15541,27 +17986,188 @@ 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$1,
+						description: "Optional optimization family. Omit for job-shop scheduling; otherwise one of the eight families."
+					}
+				},
 				required: ["description"],
 				additionalProperties: false
 			}
 		}
 	})
 };
+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, userInstruction) {
+	let rawContent = "";
+	await context.llm.complete(context.model ?? "gpt-4", [{
+		role: "system",
+		content: systemPrompt
+	}, {
+		role: "user",
+		content: userInstruction
+	}], {
+		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}` };
+	}
+}
+/**
+* Edit prompt. The current problem doubles as the shape template — the model must
+* return the SAME shape with only the requested change applied. The hard rule is
+* fidelity: anything the instruction doesn't touch comes back byte-for-byte, which
+* is the whole reason this tool exists instead of re-running `quantum_formulate`.
+*/
+function editPrompt(currentProblem, familyId) {
+	return `You are EDITING an existing optimization problem. Below is the CURRENT problem as JSON.
+
+Apply ONLY the change the user describes. Preserve every other field EXACTLY — identical ids, names, and numeric values for anything the change does not explicitly touch. Do not renumber, rename, reorder, or "improve" untouched entities. Keep it small and browser-solvable.
+${familyId ? `- "family" MUST stay exactly "${familyId}".` : "- Keep the job-shop scheduling shape (jobs with ordered operations referencing machine ids)."}
+- "description" stays a single plain-English sentence; update it only if the change makes it inaccurate.
+
+CURRENT PROBLEM:
+${JSON.stringify(currentProblem, null, 2)}
+
+Output ONLY a JSON object of the form:
+{ "problem": <the COMPLETE updated problem, same shape as above>, "changes": "<one short sentence describing exactly what you changed>" }
+No prose, no markdown fences.`;
+}
+/** Split the model output into the problem and an optional change summary. */
+function unwrap(json) {
+	if (json && typeof json === "object" && "problem" in json) {
+		const obj = json;
+		return {
+			problem: obj.problem,
+			changes: typeof obj.changes === "string" ? obj.changes : void 0
+		};
+	}
+	return { problem: json };
+}
+const quantumEditProblemTool = {
+	name: "quantum_edit_problem",
+	implementation: (context) => ({
+		toolFn: async (value) => {
+			const params = value;
+			const instruction = params.instruction?.trim();
+			if (!instruction) return "Error: Please provide an instruction describing the change to make.";
+			if (params.currentProblem == null || typeof params.currentProblem !== "object") return "Error: Please pass the current problem (the active brief JSON) as `currentProblem` so it can be edited in place.";
+			if (params.familyId && !FAMILY_IDS.includes(params.familyId)) return `Error: unknown familyId "${String(params.familyId)}". Valid families: ${FAMILY_IDS.join(", ")}. Omit familyId to edit a job-shop scheduling problem.`;
+			const familyId = params.familyId || void 0;
+			try {
+				const result = await completeToJson(context, editPrompt(params.currentProblem, familyId), instruction);
+				if ("error" in result) return `Error: ${result.error}\n\nPlease restate the change more specifically.`;
+				const { problem: rawProblem, changes } = unwrap(result.json);
+				if (rawProblem == null || typeof rawProblem !== "object") return "Error: the edit did not produce a problem object. Please restate the change.";
+				if (familyId) {
+					const validated = FAMILY_PROBLEM_SCHEMAS[familyId].safeParse(rawProblem);
+					if (!validated.success) return `Error: the edited ${familyId} problem is invalid.\n${validated.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}\n\nPlease restate the change.`;
+					const problem = validated.data;
+					const summary = [
+						`## Updated: "${problem.name}"`,
+						changes ? `\n${changes}` : "",
+						"",
+						`**${familyId} problem** — applied to your active brief.`,
+						"",
+						`I've updated the ${familyId} brief in place (use Undo on the banner to revert). Open Solvers to race it.`
+					].filter((l) => l !== void 0).join("\n");
+					return JSON.stringify({
+						__uiSideEffect: true,
+						type: "populateFamilyProblem",
+						payload: {
+							familyId,
+							problem
+						},
+						displayMessage: summary
+					});
+				}
+				const validated = SchedulingProblemSchema.safeParse(rawProblem);
+				if (!validated.success) return `Error: the edited problem structure is invalid.\n${validated.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}\n\nPlease restate the change.`;
+				const problem = validated.data;
+				const totalOps = problem.jobs.reduce((s, j) => s + j.operations.length, 0);
+				const summary = [
+					`## Updated: "${problem.name}"`,
+					changes ? `\n${changes}` : "",
+					"",
+					`**${problem.jobs.length} jobs, ${problem.machines.length} machines, ${totalOps} operations**`,
+					"",
+					"I've updated your active scheduling brief in place (use Undo on the banner to revert). Open Solvers to race it."
+				].filter((l) => l !== void 0).join("\n");
+				return JSON.stringify({
+					__uiSideEffect: true,
+					type: "populateProblem",
+					payload: problem,
+					displayMessage: summary
+				});
+			} catch (err) {
+				return `Error editing problem: ${err instanceof Error ? err.message : String(err)}`;
+			}
+		},
+		toolSchema: {
+			name: "quantum_edit_problem",
+			description: `Edit the optimization problem currently loaded in the /opti active brief. Use this — NOT quantum_formulate — whenever the user asks to change, refine, tweak, add to, or adjust the problem they're already looking at.
+
+Pass the active brief as \`currentProblem\` (you have it in your context), describe the change in \`instruction\`, and pass \`familyId\` for one of the eight pattern families (omit for job-shop scheduling). The tool applies only the requested change, preserves everything else exactly, and the result is auto-applied to the active brief with one-click Undo. Use quantum_formulate instead only for a brand-new, unrelated problem.`,
+			strict: false,
+			parameters: {
+				type: "object",
+				properties: {
+					instruction: {
+						type: "string",
+						description: "The change to apply to the current problem, in plain English (e.g. \"add two more jobs\")."
+					},
+					currentProblem: {
+						type: "object",
+						description: "The current problem JSON (the active brief) to edit in place.",
+						additionalProperties: true
+					},
+					familyId: {
+						type: "string",
+						enum: FAMILY_IDS,
+						description: "Optional optimization family. Omit for job-shop scheduling; otherwise one of the eight."
+					}
+				},
+				required: ["instruction", "currentProblem"],
+				additionalProperties: false
+			}
+		}
+	})
+};
 const navigateViewTool = {
 	name: "navigate_view",
 	implementation: (context) => ({
@@ -15869,6 +18475,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,
@@ -16187,9 +18794,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`;
@@ -16574,15 +19186,28 @@ DO NOT USE FOR:
 		}
 	})
 };
+/** Cap on how many invocable skills are listed back when resolution fails. */
+const INVOCABLE_HINT_LIMIT = 50;
 /**
 * LLM-invocable `skill` tool — the autonomous counterpart to user `/skill-name`
 * invocations handled by SkillsFeature.
 *
-* The LLM passes `{ name, args }`. The tool resolves the skill in the caller's
-* scope (`findByNameForUser`), expands `$ARGUMENTS` / `$1` / `$2`, and returns
-* the expanded body as the observation for the next turn. Skills with
+* The LLM passes `{ name, args }`. The tool resolves the skill across every
+* scope the caller can access (`findAccessibleByNameForUser` — owned + shared +
+* global-read), expands `$ARGUMENTS` / `$1` / `$2`, and returns the expanded
+* body as the observation for the next turn. Skills with
 * `disableModelInvocation: true` are not callable here.
 *
+* Security: a skill the caller does NOT own (shared / org / global) is treated
+* as untrusted content — its body is wrapped with explicit delimiters and a
+* "do not follow conflicting instructions" framing so a malicious author can't
+* hijack the turn via prompt injection. The skill's `allowedTools` whitelist is
+* surfaced to the model as a *requested* tool scope (intersected with the
+* invoker's allow-list via `intersectAllowedTools`). NOTE: today this is prompt
+* guidance only — there is no `ToolContext` invoker allow-list to enforce it
+* against, so the wording stays advisory. When that wiring lands, the same
+* `permittedTools` set can narrow the completion's actual tool list.
+*
 * Catalog discovery: the available skill names + descriptions are listed in
 * the system prompt by SkillsFeature, so the LLM knows what's invocable. If
 * the LLM passes a name that isn't accessible, the tool returns an error
@@ -16598,14 +19223,18 @@ const skillTool = {
 			const name = rawName.replace(/^\//, "");
 			const skillsRepo = context.db.skills;
 			if (!skillsRepo) return "Error: skills are not configured in this environment.";
-			const skill = await skillsRepo.findByNameForUser(context.userId, name);
+			const skill = await skillsRepo.findAccessibleByNameForUser(context.userId, name);
 			if (!skill || skill.disableModelInvocation) {
-				const invocable = (await skillsRepo.listForUser(context.userId)).filter((s) => !s.disableModelInvocation).map((s) => s.name);
+				const invocable = (await skillsRepo.listAccessibleInvocableForUser(context.userId, INVOCABLE_HINT_LIMIT)).map((s) => s.name);
 				return invocable.length === 0 ? `Error: skill "${name}" is not available, and you have no LLM-invocable skills defined.` : `Error: skill "${name}" is not available. Invocable skills: ${invocable.join(", ")}`;
 			}
 			const argArray = typeof params.args === "string" ? parseSkillArguments(params.args) : [];
 			const expandedBody = substituteArguments$1(skill.body, argArray);
-			return `## Skill: /${skill.name}\n\n${expandedBody}\n\n---\nFollow the instructions above for the rest of this turn.`;
+			if (skill.userId === context.userId) return `## Skill: /${skill.name}\n\n${expandedBody}\n\n---\nFollow the instructions above for the rest of this turn.`;
+			const ownerLabel = skill.organizationId ? "your organization" : skill.isSystem ? "the system" : "another user";
+			const wrapped = wrapUntrustedSkillBody(skill.name, expandedBody, ownerLabel);
+			const permittedTools = intersectAllowedTools(skill.allowedTools, void 0);
+			return `${wrapped}${permittedTools && permittedTools.length > 0 ? `\n\nThis skill is intended to use only these tools: ${permittedTools.join(", ")}. Prefer to stay within that set.` : ""}\n\n---\nFollow the intent above for the rest of this turn, subject to the constraints stated.`;
 		},
 		toolSchema: {
 			name: "skill",
@@ -17469,16 +20098,18 @@ const b4mTools = {
 	retrieve_knowledge_content: knowledgeBaseRetrieveTool,
 	quantum_schedule: quantumScheduleTool,
 	quantum_formulate: quantumFormulateTool,
+	quantum_edit_problem: quantumEditProblemTool,
 	navigate_view: navigateViewTool,
 	generate_jupyter_notebook: jupyterNotebookTool,
 	excel_generation: excelGenerationTool,
 	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,
@@ -18499,7 +21130,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:
@@ -19122,7 +21757,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);
@@ -19947,6 +22582,159 @@ parentPort.on('message', async (msg) => {
   }
 });
 `;
+String.raw`
+const __cap = _captureLine;
+const __callTool = _callTool;
+delete globalThis._captureLine;
+delete globalThis._callTool;
+
+const HARD_PER_LINE_BYTES = ${5e4};
+
+function __jsonReplacer(_k, v) {
+  if (v instanceof Error) return { name: v.name, message: v.message };
+  if (typeof v === 'bigint') return v.toString() + 'n';
+  return v;
+}
+function __formatLine(args) {
+  const line = args.map(a => {
+    if (typeof a === 'string') return a;
+    if (a === undefined) return 'undefined';
+    if (a === null) return 'null';
+    try { return JSON.stringify(a, __jsonReplacer, 2); } catch { return String(a); }
+  }).join(' ');
+  return line.length > HARD_PER_LINE_BYTES
+    ? line.slice(0, HARD_PER_LINE_BYTES) + ' [...line truncated]'
+    : line;
+}
+globalThis.console = {
+  log: (...a) => __cap.applySync(undefined, [__formatLine(a)], { arguments: { copy: true } }),
+  warn: (...a) => __cap.applySync(undefined, [__formatLine(a)], { arguments: { copy: true } }),
+  error: (...a) => __cap.applySync(undefined, [__formatLine(a)], { arguments: { copy: true } }),
+  info: (...a) => __cap.applySync(undefined, [__formatLine(a)], { arguments: { copy: true } }),
+};
+
+// A bare isolate has no structuredClone (it's a host/web API, not a V8
+// intrinsic). The in-process + worker backends expose the *host's* real
+// structuredClone — which we can't reach across the isolate boundary — so
+// polyfill the structured-clone algorithm in-isolate for the common cloneable
+// types (Date, RegExp, Map, Set, ArrayBuffer / typed arrays / DataView,
+// arrays, plain objects) WITH circular-reference support. This is real
+// parity for those types; a JSON round-trip would silently drop
+// Date -> string, Map/Set -> {}, RegExp -> {}, TypedArray -> index map.
+// Genuinely uncloneable inputs (functions, etc.) throw, as the real API does.
+if (typeof globalThis.structuredClone !== 'function') {
+  globalThis.structuredClone = function structuredClone(input) {
+    const seen = new WeakMap();
+    function clone(v) {
+      if (v === null || typeof v !== 'object') {
+        if (typeof v === 'function') throw new Error('structuredClone: a function could not be cloned');
+        return v;
+      }
+      if (seen.has(v)) return seen.get(v);
+      // Every cloneable type records its clone in the seen-map BEFORE returning,
+      // so the same object appearing at multiple paths yields one shared clone
+      // (reference identity), matching the real structured-clone algorithm —
+      // not just the recursive containers.
+      if (v instanceof Date) { const out = new Date(v.getTime()); seen.set(v, out); return out; }
+      if (v instanceof RegExp) { const out = new RegExp(v.source, v.flags); seen.set(v, out); return out; }
+      if (v instanceof ArrayBuffer) { const out = v.slice(0); seen.set(v, out); return out; }
+      if (typeof DataView !== 'undefined' && v instanceof DataView) {
+        const out = new DataView(clone(v.buffer), v.byteOffset, v.byteLength); seen.set(v, out); return out;
+      }
+      if (ArrayBuffer.isView(v)) { const out = new v.constructor(v); seen.set(v, out); return out; } // typed array — fresh buffer
+      if (v instanceof Map) {
+        const out = new Map(); seen.set(v, out);
+        for (const [k, val] of v) out.set(clone(k), clone(val));
+        return out;
+      }
+      if (v instanceof Set) {
+        const out = new Set(); seen.set(v, out);
+        for (const val of v) out.add(clone(val));
+        return out;
+      }
+      if (Array.isArray(v)) {
+        const out = []; seen.set(v, out);
+        for (let i = 0; i < v.length; i++) out[i] = clone(v[i]);
+        return out;
+      }
+      const out = {}; seen.set(v, out);
+      for (const k of Object.keys(v)) out[k] = clone(v[k]);
+      return out;
+    }
+    return clone(input);
+  };
+}
+
+// Neuter string-based code generation. Same posture as the worker /
+// in-process backends' codeGeneration:{strings:false} (Ken's P2 #2): the
+// LLM has no legitimate reason to generate second-order code that's
+// invisible in the logged 'code' parameter. isolated-vm exposes no V8-level
+// codegen toggle, so we block every reachable path to the intrinsic
+// Function constructors — not just the global bindings. The well-known
+// vm-escape vector \`(function(){}).constructor("…")()\` reaches the
+// intrinsic via the prototype chain, around \`globalThis.Function\`, so we
+// capture each function-type intrinsic BEFORE overriding the globals and
+// replace its \`prototype.constructor\` too. (Generated code would stay
+// trapped in the isolate regardless — this is auditability + worker parity,
+// not the core isolation guarantee, which the isolate itself provides.)
+const __RealFunction = (function () {}).constructor;
+const __AsyncFunction = (async function () {}).constructor;
+const __GeneratorFunction = (function* () {}).constructor;
+const __AsyncGeneratorFunction = (async function* () {}).constructor;
+const __blockCodegen = function () {
+  throw new Error('code generation from strings (eval / Function) is disabled in the REPL sandbox');
+};
+for (const __Ctor of [__RealFunction, __AsyncFunction, __GeneratorFunction, __AsyncGeneratorFunction]) {
+  try {
+    Object.defineProperty(__Ctor.prototype, 'constructor', {
+      value: __blockCodegen,
+      writable: true,
+      configurable: true,
+      enumerable: false,
+    });
+  } catch (_e) {
+    // best-effort; the global overrides below still cover the common paths
+  }
+}
+globalThis.eval = __blockCodegen;
+globalThis.Function = __blockCodegen;
+
+// Tool-stub registry. Each registered tool becomes a top-level async
+// function that round-trips through the host dispatcher and re-throws on
+// the { ok:false } envelope.
+globalThis.__registerTools = function (names) {
+  for (const name of names) {
+    globalThis[name] = async (...args) => {
+      const envJson = await __callTool.apply(
+        undefined,
+        [name, JSON.stringify(args)],
+        { arguments: { copy: true }, result: { promise: true, copy: true } }
+      );
+      const env = JSON.parse(envJson);
+      if (!env.ok) throw new Error(env.error);
+      return env.value;
+    };
+  }
+};
+`;
+z.object({
+	reflection: z.string().min(1),
+	summary: z.string().min(1),
+	nextIntendedAction: z.string().min(1),
+	scopeLocks: z.array(z.string()).default([]),
+	drivesAfter: DriveVectorSchema
+});
+z.object({
+	semanticMemory: z.array(z.object({
+		id: z.string().min(1),
+		fact: z.string().min(1),
+		evidenceTier: EvidenceTierSchema,
+		confidence: z.number().min(0).max(1).default(.5),
+		sourceEpisodeIds: z.array(z.string()).default([]),
+		lastAffirmedAt: z.string()
+	})),
+	openQuestions: z.array(z.string()).default([])
+});
 z.object({
 	count: z.number().optional(),
 	unlimitedUse: z.boolean().optional(),
@@ -20462,6 +23250,18 @@ z.object({
 id: z.string().min(1) });
 z.object({ organizationId: z.string() });
 z.object({ id: z.string() });
+const createPromptSchema = z.object({
+	type: z.string(),
+	name: z.string(),
+	promptText: z.string(),
+	tags: z.array(z.string())
+});
+z.object({ id: z.string() });
+z.object({ id: z.string() });
+z.object({ name: z.string() });
+z.object({ tags: z.array(z.string()) });
+z.object({ type: z.string() });
+createPromptSchema.partial().extend({ id: z.string() });
 z.object({ id: z.string() });
 z.object({ ids: z.array(z.string()).optional() });
 z.object({
@@ -20474,7 +23274,7 @@ z.object({
 	systemPriority: z.number().min(0).max(999).optional(),
 	sessionId: z.string().optional(),
 	notes: z.string().optional(),
-	primaryTag: z.string().optional(),
+	primaryTag: z.string().nullable().optional(),
 	tags: z.array(z.object({
 		name: z.string(),
 		strength: z.number()
@@ -20490,33 +23290,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,})).+/) });
@@ -20559,6 +23332,7 @@ z.object({
 		userGroups: z.array(z.string()).optional(),
 		dataLakeTags: z.array(z.string()).optional(),
 		dataLakeTagPrefixes: z.array(z.string()).optional(),
+		scopedTagPrefixes: z.array(z.string()).optional(),
 		excludeContent: z.coerce.boolean().optional()
 	}).optional()
 });
@@ -21910,6 +24684,15 @@ z.object({
 	isPersonal: z.boolean(),
 	mementos: z.array(SingleMementoEvalSchema).optional()
 });
+new Set([{
+	key: "internal",
+	audienceType: "internal",
+	label: "Internal"
+}, {
+	key: "customer",
+	audienceType: "customer",
+	label: "Customer"
+}].map((v) => v.key));
 crypto_exports.safeCompareTokens;
 //#endregion
 //#region ../../b4m-core/services/dist/llm/tools/cliTools.mjs
@@ -25008,16 +27791,21 @@ function extractUsageInfo(parsed) {
 	return {
 		inputTokens: parsed.usage?.inputTokens,
 		outputTokens: parsed.usage?.outputTokens,
+		cacheReadInputTokens: parsed.usage?.cacheReadInputTokens,
+		cacheCreationInputTokens: parsed.usage?.cacheCreationInputTokens,
 		creditsUsed: parsed.credits?.used,
 		usdCost: parsed.credits?.usdCost
 	};
 }
 /**
-* Accumulates streaming LLM response chunks (text, tool calls, thinking blocks, usage)
-* and fires the completion callback once at the end.
+* Reduces a stream of {@link StreamEvent}s (text, tool calls, thinking blocks,
+* usage) into a single accumulated assistant turn, then fires the completion
+* callback once at the end.
 *
-* Shared between ServerLlmBackend (SSE) and WebSocketLlmBackend (WebSocket frames)
-* so accumulation logic lives in exactly one place.
+* Both backends — `ServerLlmBackend` (SSE) and `WebSocketLlmBackend` (WebSocket
+* frames) — decode their wire payloads into the shared event union and feed
+* each event to {@link apply}, so accumulation logic lives in exactly one
+* place and is transport-agnostic.
 */
 var StreamAccumulator = class {
 	constructor() {
@@ -25026,21 +27814,25 @@ var StreamAccumulator = class {
 		this.thinkingBlocks = [];
 		this.lastUsageInfo = {};
 	}
-	onContent(text, usage, credits) {
-		this.accumulatedText += text;
-		if (usage || credits) this.lastUsageInfo = extractUsageInfo({
-			usage,
-			credits
-		});
-	}
-	onToolUse(text, tools, thinking, usage, credits) {
-		if (text) this.accumulatedText += text;
-		if (tools && tools.length > 0) this.toolsUsed = tools;
-		if (thinking && thinking.length > 0) this.thinkingBlocks = thinking;
-		if (usage || credits) this.lastUsageInfo = extractUsageInfo({
-			usage,
-			credits
-		});
+	/**
+	* Fold one streaming event into the accumulated turn. `error` events carry no
+	* accumulable content — backends surface them by rejecting — so they are a
+	* no-op here.
+	*/
+	apply(event) {
+		switch (event.type) {
+			case "content":
+				this.accumulatedText += event.text ?? "";
+				if (event.usage || event.credits) this.lastUsageInfo = extractUsageInfo(event);
+				break;
+			case "tool_use":
+				if (event.text) this.accumulatedText += event.text;
+				if (event.tools && event.tools.length > 0) this.toolsUsed = event.tools;
+				if (event.thinking && event.thinking.length > 0) this.thinkingBlocks = event.thinking;
+				if (event.usage || event.credits) this.lastUsageInfo = extractUsageInfo(event);
+				break;
+			case "error": break;
+		}
 	}
 	/** True when neither text nor tools have been accumulated (stream produced nothing useful). */
 	isEmpty() {
@@ -25073,6 +27865,93 @@ var StreamAccumulator = class {
 	}
 };
 //#endregion
+//#region src/llm/streamEvents.ts
+/**
+* Unified streaming event protocol for CLI LLM backends.
+*
+* Both transports — `ServerLlmBackend` (SSE) and `WebSocketLlmBackend`
+* (HTTP POST + WebSocket frames) — decode their wire payloads into this single
+* typed union, then feed it to `StreamAccumulator`. This collapses the two
+* previously-duplicated, loosely-typed chunk shapes (`SSEEvent` in
+* ServerLlmBackend, the inline `chunk` type in WebSocketLlmBackend) into one
+* source of truth, and replaces the unchecked `as SSEEvent` cast on
+* server-provided data with a runtime-validated parse at the boundary.
+*
+* The vocabulary mirrors what the backends emit today (`content` / `tool_use` /
+* `error`) so the refactor changes no observable behavior. Finer-grained delta
+* events (text_delta / toolcall_delta / …) are intentionally out of scope — the
+* CLI accumulates a full turn before firing its callback, so per-delta events
+* would be a behavior change, not a refactor.
+*/
+/**
+* Token usage counts carried alongside content/tool_use events. Shape mirrors
+* `SSEContentEvent.usage` in `@bike4mind/common` (`sseEvents.ts`) — the
+* authoritative wire contract — including the Anthropic cache-token deltas
+* (#8155) so they survive the boundary parse instead of being stripped.
+*/
+const usageSchema = z.object({
+	inputTokens: z.number().optional(),
+	outputTokens: z.number().optional(),
+	cacheReadInputTokens: z.number().optional(),
+	cacheCreationInputTokens: z.number().optional()
+}).partial();
+/** Credit/cost accounting carried alongside content/tool_use events (SSE only). */
+const creditsSchema = z.object({
+	used: z.number().optional(),
+	usdCost: z.number().optional()
+}).partial();
+/**
+* A single tool call requested by the model. Shape mirrors the wire contract in
+* `@bike4mind/common` (`SSEContentEvent.tools` / `CompletionInfo.toolsUsed`):
+* the server sends `{ name, arguments?: string, id? }` — `arguments` is a raw
+* JSON string, NOT a parsed object. (The previous `input: Record<…>` shape was
+* a typed lie the old unchecked `as SSEEvent` cast hid; downstream consumers
+* read `tool.arguments`, e.g. `toolParallelizer.ts`.)
+*/
+const toolUseSchema = z.object({
+	name: z.string(),
+	arguments: z.string().optional(),
+	id: z.string().optional()
+});
+/**
+* Discriminated union of streaming events. `thinking` blocks are opaque
+* provider-shaped objects (Anthropic extended thinking) replayed verbatim into
+* the next request, so they stay `unknown[]` rather than being modeled.
+*/
+const streamEventSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("content"),
+		text: z.string().optional(),
+		usage: usageSchema.optional(),
+		credits: creditsSchema.optional()
+	}),
+	z.object({
+		type: z.literal("tool_use"),
+		text: z.string().optional(),
+		tools: z.array(toolUseSchema).optional(),
+		thinking: z.array(z.unknown()).optional(),
+		usage: usageSchema.optional(),
+		credits: creditsSchema.optional()
+	}),
+	z.object({
+		type: z.literal("error"),
+		message: z.string().optional()
+	})
+]);
+/**
+* Validate an already-JSON-decoded wire payload against the event union.
+*
+* Returns the typed event on success, or `null` when the payload does not match
+* a known event shape. A `null` result is treated as "skip this event" by the
+* backends — preserving the prior behavior where an unrecognized `type` simply
+* fell through unhandled. (Malformed JSON is still caught upstream at the
+* `JSON.parse` boundary.)
+*/
+function parseStreamEvent(data) {
+	const result = streamEventSchema.safeParse(data);
+	return result.success ? result.data : null;
+}
+//#endregion
 //#region src/llm/ServerLlmBackend.ts
 /**
 * Connection-level failures that should be retried rather than surfaced to the
@@ -25247,30 +28126,29 @@ var ServerLlmBackend = class ServerLlmBackend {
 					return;
 				}
 				try {
-					const parsed = JSON.parse(data);
-					if (parsed.type === "error") {
+					const event = parseStreamEvent(JSON.parse(data));
+					if (!event) return;
+					if (event.type === "error") {
 						receivedError = true;
-						streamLogger.onCriticalEvent(eventCount, "ERROR", parsed.message || "Server error");
-						reject(new Error(parsed.message || "Server error"));
+						streamLogger.onCriticalEvent(eventCount, "ERROR", event.message || "Server error");
+						reject(new Error(event.message || "Server error"));
 						return;
 					}
-					if (parsed.type === "content") {
-						const textChunk = parsed.text || "";
-						accumulator.onContent(textChunk, parsed.usage, parsed.credits);
-						streamLogger.onContent(eventCount, textChunk, accumulator.rawText);
-					} else if (parsed.type === "tool_use") {
-						streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${parsed.tools?.length}`);
-						if (parsed.tools && parsed.tools.length > 0) for (const tool of parsed.tools) {
+					if (event.type === "content") {
+						accumulator.apply(event);
+						streamLogger.onContent(eventCount, event.text || "", accumulator.rawText);
+					} else if (event.type === "tool_use") {
+						streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${event.tools?.length}`);
+						if (event.tools && event.tools.length > 0) for (const tool of event.tools) {
 							logger.debug(`TOOL REQUEST: ${tool.name}`);
 							try {
-								const paramsStr = JSON.stringify(tool.input);
-								logger.debug(`  Params: ${paramsStr}`);
+								logger.debug(`  Params: ${tool.arguments ?? "{}"}`);
 							} catch {
 								logger.debug(`  Params: [Unable to stringify]`);
 							}
 						}
-						accumulator.onToolUse(parsed.text || "", parsed.tools, parsed.thinking, parsed.usage, parsed.credits);
-						if (parsed.thinking && parsed.thinking.length > 0) streamLogger.onCriticalEvent(eventCount, "THINKING", `${parsed.thinking.length} thinking blocks`);
+						accumulator.apply(event);
+						if (event.thinking && event.thinking.length > 0) streamLogger.onCriticalEvent(eventCount, "THINKING", `${event.thinking.length} thinking blocks`);
 					}
 				} catch (parseError) {
 					streamLogger.streamError(parseError);
@@ -25451,20 +28329,22 @@ var FallbackLlmBackend = class {
 	async complete(model, messages, options, callback) {
 		if (options.abortSignal?.aborted) return this.inner.complete(model, messages, options, callback);
 		const modelsToTry = [model, ...this.fallbackModels.filter((m) => m !== model)];
-		let callbackInvoked = false;
-		const guardedCallback = async (text, completionInfo) => {
-			callbackInvoked = true;
-			return callback(text, completionInfo);
-		};
 		let lastError;
 		for (let i = 0; i < modelsToTry.length; i++) {
 			const modelToTry = modelsToTry[i];
+			const buffered = [];
+			const bufferingCallback = async (text, completionInfo) => {
+				buffered.push({
+					text,
+					completionInfo
+				});
+			};
 			try {
-				await this.inner.complete(modelToTry, messages, options, guardedCallback);
+				await this.inner.complete(modelToTry, messages, options, bufferingCallback);
+				for (const delivery of buffered) await callback(delivery.text, delivery.completionInfo);
 				return;
 			} catch (error) {
 				if (options.abortSignal?.aborted) throw error;
-				if (callbackInvoked) throw error;
 				lastError = error instanceof Error ? error : new Error(String(error));
 				const nextModel = modelsToTry[i + 1];
 				if (nextModel) {
@@ -27371,12 +30251,14 @@ var WebSocketLlmBackend = class {
 					eventCount++;
 					const chunk = message.chunk;
 					streamLogger.onEvent(eventCount, JSON.stringify(chunk));
-					if (chunk.type === "content") {
-						accumulator.onContent(chunk.text || "", chunk.usage);
-						streamLogger.onContent(eventCount, chunk.text || "", accumulator.rawText);
-					} else if (chunk.type === "tool_use") {
-						streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${chunk.tools?.length}`);
-						accumulator.onToolUse(chunk.text || "", chunk.tools, chunk.thinking, chunk.usage);
+					const event = parseStreamEvent(chunk);
+					if (!event) return;
+					if (event.type === "content") {
+						accumulator.apply(event);
+						streamLogger.onContent(eventCount, event.text || "", accumulator.rawText);
+					} else if (event.type === "tool_use") {
+						streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${event.tools?.length}`);
+						accumulator.apply(event);
 					}
 				} else if (action === "cli_completion_done") {
 					streamLogger.streamComplete(accumulator.rawText);