@bike4mind/cli 0.18.1 → 0.18.3

package/dist/{BackgroundAgentManager-BEPNKfmi.mjs → BackgroundAgentManager-H_MnlEXz.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-BbTg-UaE.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-CSa_ad8r.mjs";
+import { t as version } from "./package-B-ONmxJ7.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";
@@ -28,7 +28,7 @@ import { Logger, Logger as Logger$1 } from "@bike4mind/observability";
 import { BEDROCK_EMBEDDING_MODEL_MAP, BaseStorage, BaseStorage as BaseStorage$1, BedrockEmbeddingService, ChunkSchema, EmbeddingFactory, EmbeddingModelProvider, EmbeddingService, OPENAI_EMBEDDING_MODEL_MAP, OpenAIEmbeddingService, S3Storage, SmartChunker, URL_REGEX, VOYAGEAI_EMBEDDING_MODEL_MAP, VoyageAIEmbeddingProvider, detectURLs, detectURLs as detectURLs$1, fetchAndParseURL, fetchAndParseURL as fetchAndParseURL$1, getProviderFromModel, hasURLs, hasURLs as hasURLs$1, isPrivateIP, isPrivateOrInternalHostname, urlExists, validateUrlForFetch } from "@bike4mind/fab-pipeline";
 import * as dotenv from "dotenv";
 import * as import__bike4mind_llm_adapters from "@bike4mind/llm-adapters";
-import { OpenAIBackend, ensureToolPairingIntegrity } from "@bike4mind/llm-adapters";
+import { OpenAIBackend, ensureToolPairingIntegrity, toProviderEndUserId } from "@bike4mind/llm-adapters";
 import { fileTypeFromBuffer } from "file-type";
 import invert from "lodash/invert.js";
 import * as util from "node:util";
@@ -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,
@@ -10738,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,
@@ -13491,7 +13521,7 @@ const FAMILY_SAMPLE_PROBLEMS = {
 	continuous: continuousSampleProblems
 };
 //#endregion
-//#region ../../b4m-core/services/dist/tools-BhiSgg5-.mjs
+//#region ../../b4m-core/services/dist/tools-BIrr-Tc6.mjs
 const createFabFileSchema = z.object({
 	fileName: z.string(),
 	mimeType: z.string(),
@@ -13683,7 +13713,7 @@ async function performDeepResearch(context, params, config = {}) {
 		let analysisLlm = context.llm;
 		let analysisModel = config.model || ChatModels.GPT4_1;
 		if (config.apiKeys?.openai) try {
-			analysisLlm = new OpenAIBackend(config.apiKeys.openai, context.logger);
+			analysisLlm = new OpenAIBackend(config.apiKeys.openai, context.logger, toProviderEndUserId(context.userId));
 			analysisModel = ChatModels.GPT4_1;
 			log("🔬 Deep Research: Using GPT-4.1 for analysis");
 		} catch (error) {
@@ -13919,18 +13949,21 @@ 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, organizationId)).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,
@@ -13964,6 +13997,7 @@ async function semanticDataLakeSearch(params, adapters) {
 		userGroups,
 		dataLakeTags,
 		dataLakeTagPrefixes,
+		scopedTagPrefixes,
 		excludeContent: true
 	});
 	const fileIds = fileSearch.data.map((f) => f.id);
@@ -14876,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: {
@@ -17295,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,
@@ -17308,6 +17342,7 @@ async function trySemanticKbSearch(context, query, tags, maxResults) {
 			apiKeyTable,
 			dataLakeTags,
 			dataLakeTagPrefixes,
+			scopedTagPrefixes,
 			logger: context.logger
 		}, { db: {
 			fabfiles: context.db.fabfiles,
@@ -17381,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,
@@ -17398,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)));
@@ -17545,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
@@ -17561,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.`;
@@ -17664,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 }] }`;
@@ -17709,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",
@@ -17723,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: {
@@ -17814,7 +17865,7 @@ The problem must define jobs (each with ordered operations) and machines. Each o
 		}
 	})
 };
-const FAMILY_IDS = [
+const FAMILY_IDS$1 = [
 	"routing",
 	"packing",
 	"assignment",
@@ -17825,7 +17876,7 @@ const FAMILY_IDS = [
 	"continuous"
 ];
 /** Run the model and pull a JSON object out of the response (handles code fences). */
-async function completeToJson(context, systemPrompt, userDescription) {
+async function completeToJson$1(context, systemPrompt, userDescription) {
 	let rawContent = "";
 	await context.llm.complete(context.model ?? "gpt-4", [{
 		role: "system",
@@ -17860,6 +17911,7 @@ 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 = {
@@ -17869,11 +17921,11 @@ const quantumFormulateTool = {
 			const params = value;
 			const userDescription = params.description?.trim();
 			if (!userDescription) return "Error: Please provide a description of the optimization problem to formulate.";
-			if (params.familyId && !FAMILY_IDS.includes(params.familyId)) return `Error: unknown familyId "${String(params.familyId)}". Valid families: ${FAMILY_IDS.join(", ")}. Omit familyId to formulate a job-shop scheduling problem.`;
+			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 {
 				if (familyId) {
-					const result = await completeToJson(context, familyFormulationPrompt(familyId), userDescription);
+					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.`;
@@ -17882,9 +17934,9 @@ const quantumFormulateTool = {
 						`## Formulated: "${problem.name}"`,
 						problem.description ? `\n${problem.description}` : "",
 						"",
-						`**${familyId} problem** — ready to load.`,
+						`**${familyId} problem** — loaded into your active brief.`,
 						"",
-						`Open the ${familyId} console's Problem tab and click "Load problem" on the pending banner to review, tweak, and race solvers.`
+						`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,
@@ -17896,7 +17948,7 @@ const quantumFormulateTool = {
 						displayMessage: summary
 					});
 				}
-				const result = await completeToJson(context, PROBLEM_FORMULATION_PROMPT, userDescription);
+				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.`;
@@ -17920,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,
@@ -17952,7 +18004,7 @@ Describe the scenario in plain English — the entities, resources, costs/values
 					},
 					familyId: {
 						type: "string",
-						enum: FAMILY_IDS,
+						enum: FAMILY_IDS$1,
 						description: "Optional optimization family. Omit for job-shop scheduling; otherwise one of the eight families."
 					}
 				},
@@ -17962,6 +18014,160 @@ Describe the scenario in plain English — the entities, resources, costs/values
 		}
 	})
 };
+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) => ({
@@ -18980,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
@@ -19004,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",
@@ -19875,6 +20098,7 @@ 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,
@@ -22358,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(),
@@ -22873,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({
@@ -22885,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()
@@ -22943,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()
 });
@@ -24294,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
@@ -27392,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() {
@@ -27410,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() {
@@ -27457,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
@@ -27631,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);
@@ -27835,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) {
@@ -29755,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);