@bike4mind/cli 0.20.2 → 0.22.0

package/dist/{ConfigStore-cIyF7hDg.mjs → ConfigStore-8_0WsN5r.mjs}

@@ -7,7 +7,6 @@ import path from "path";
 import { v4 } from "uuid";
 import * as z$2 from "zod";
 import z, { ZodError, z as z$1 } from "zod";
-import { actorKindSchema, hearthEventKindSchema, hearthEventRefsSchema, hearthMachineBodySchema } from "@bike4mind/hearth";
 import dayjs from "dayjs";
 import timezone from "dayjs/plugin/timezone.js";
 import utc from "dayjs/plugin/utc.js";
@@ -52,7 +51,7 @@ const extractSnippetMeta = (content) => {
 	}
 	return { sections };
 };
-function getHeader(headers, name) {
+function getHeader$1(headers, name) {
 	if (!headers || typeof headers !== "object") return null;
 	if (typeof headers.get === "function") {
 		const val = headers.get(name);
@@ -76,10 +75,10 @@ function parseNumber(value) {
 * - `Retry-After` - seconds to wait (on 429 responses), or an HTTP-date
 */
 function parseRateLimitHeaders(headers) {
-	const limitStr = getHeader(headers, "X-RateLimit-Limit") ?? getHeader(headers, "x-ratelimit-limit");
-	const remainingStr = getHeader(headers, "X-RateLimit-Remaining") ?? getHeader(headers, "x-ratelimit-remaining");
-	const resetStr = getHeader(headers, "X-RateLimit-Reset") ?? getHeader(headers, "x-ratelimit-reset");
-	const retryAfterStr = getHeader(headers, "Retry-After") ?? getHeader(headers, "retry-after");
+	const limitStr = getHeader$1(headers, "X-RateLimit-Limit") ?? getHeader$1(headers, "x-ratelimit-limit");
+	const remainingStr = getHeader$1(headers, "X-RateLimit-Remaining") ?? getHeader$1(headers, "x-ratelimit-remaining");
+	const resetStr = getHeader$1(headers, "X-RateLimit-Reset") ?? getHeader$1(headers, "x-ratelimit-reset");
+	const retryAfterStr = getHeader$1(headers, "Retry-After") ?? getHeader$1(headers, "retry-after");
 	const limit = parseNumber(limitStr);
 	const remaining = parseNumber(remainingStr);
 	let resetAt = null;
@@ -110,13 +109,6 @@ function parseRateLimitHeaders(headers) {
 		usagePercent
 	};
 }
-/**
-* Check whether the current rate limit usage is near the threshold.
-*
-* @param info - Parsed rate limit info
-* @param thresholdPercent - Usage percentage threshold (default: 80)
-* @returns true if usage is at or above the threshold
-*/
 function isNearLimit(info, thresholdPercent = 80) {
 	if (info.usagePercent === null) return false;
 	return info.usagePercent >= thresholdPercent;
@@ -140,6 +132,151 @@ function buildRateLimitLogEntry(integration, endpoint, info, wasThrottled = fals
 	};
 }
 //#endregion
+//#region ../../b4m-core/hearth/dist/index.mjs
+/**
+* Zod validation for data crossing the Hearth boundary (API routes, CLI
+* tools, gateways). Must stay in sync with the types in types.ts.
+*/
+const actorKindSchema = z$1.enum([
+	"human",
+	"agent",
+	"gateway",
+	"device",
+	"system"
+]);
+/**
+* The kinds a caller may claim FOR ITSELF. 'human' and 'system' are reserved:
+* the human actor is derived from the authenticated session, never from a
+* request body, so no credential can post an event that renders as the account
+* owner. Claiming one of these three is a downgrade in trust, not a spoof.
+*
+* Single source for both self-identification paths - the actor override and the
+* per-session kind (see HearthActorParamSchema / HearthSessionParamSchema in
+* the client's hearthWire) - so the reserved set cannot drift between them.
+*/
+const selfClaimedActorKindSchema = z$1.enum([
+	"agent",
+	"gateway",
+	"device"
+]);
+const hearthEventKindSchema = z$1.enum([
+	"message",
+	"edit",
+	"reaction",
+	"artifact",
+	"presence",
+	"delegation",
+	"quest.update",
+	"gate.request",
+	"gate.resolve",
+	"system"
+]);
+const hearthHumanBodySchema = z$1.object({
+	text: z$1.string().min(1),
+	format: z$1.enum(["md", "text"])
+});
+const hearthMachineBodySchema = z$1.object({
+	schema: z$1.string().min(1),
+	payload: z$1.unknown()
+});
+const hearthEventRefsSchema = z$1.object({
+	threadRootId: z$1.string().min(1).optional(),
+	replyToId: z$1.string().min(1).optional(),
+	questId: z$1.string().min(1).optional(),
+	externalId: z$1.string().min(1).optional()
+});
+z$1.object({
+	channelId: z$1.string().min(1),
+	actorId: z$1.string().min(1),
+	kind: hearthEventKindSchema,
+	human: hearthHumanBodySchema,
+	machine: hearthMachineBodySchema.optional(),
+	refs: hearthEventRefsSchema
+});
+/** djb2. Deterministic across processes and restarts, which is the whole point. */
+function hashOf(value) {
+	let hash = 5381;
+	for (let i = 0; i < value.length; i++) hash = (hash << 5) + hash + value.charCodeAt(i) | 0;
+	return Math.abs(hash);
+}
+/**
+* Stable palette slot for an actor. Hash-derived, never array index or arrival
+* order: those repaint every actor whenever the tail changes or a reload
+* reorders the buffer, and a shifting color is worse than no color for telling
+* two agents apart.
+*/
+function actorColorIndex(actorId) {
+	if (!actorId) return 0;
+	return hashOf(actorId) % 4;
+}
+const ACTOR_COLOR_SLOTS = [
+	{
+		light: "#2a78d6",
+		dark: "#3987e5"
+	},
+	{
+		light: "#eda100",
+		dark: "#c98500"
+	},
+	{
+		light: "#e87ba4",
+		dark: "#d55181"
+	},
+	{
+		light: "#008300",
+		dark: "#008300"
+	}
+];
+/** Single-character marker for text-only surfaces (the CLI /hearth listing). */
+const ACTOR_KIND_MARKERS = {
+	human: "H",
+	agent: "A",
+	gateway: "G",
+	device: "D",
+	system: "S"
+};
+/**
+* Read through a Partial view on purpose. The type is closed within one build,
+* but the SPA bare-casts the WS payload, so a client running stale code against
+* a server that has added a kind receives one that is absent from these maps -
+* and a blank badge reads as "no kind stated" rather than "kind unknown", which
+* is the opposite of what the mitigation needs to say.
+*/
+function lookup(map, kind, fallback) {
+	if (!kind) return fallback;
+	return map[kind] ?? fallback;
+}
+function actorKindMarker(kind) {
+	return lookup(ACTOR_KIND_MARKERS, kind, "?");
+}
+z$1.object({
+	/** Claude Code lifecycle event name; the reason fallback for tiers 0 and 1. */
+	hook_event_name: z$1.string().nullish(),
+	session_id: z$1.string().nullish(),
+	slug: z$1.string().nullish(),
+	/** Workspace BASENAME. Never a full path - that is content. */
+	workspace: z$1.string().nullish(),
+	/**
+	* Which reporter wrote this. A LOOSE string, not an enum: a fourth surface
+	* posting an unrecognized value must land on the roster with its detail
+	* intact, and a strict enum would fail the whole parse and drop the row - the
+	* exact "a third reporter is expensive" cost this contract exists to remove.
+	*/
+	surface: z$1.string().nullish(),
+	/** Engine driving the session, where the reporter knows it. */
+	source: z$1.string().nullish(),
+	claude_version: z$1.string().nullish(),
+	activity: z$1.object({
+		reason: z$1.string().nullish(),
+		tool: z$1.string().nullish(),
+		permission_mode: z$1.string().nullish(),
+		effort: z$1.string().nullish(),
+		duration_ms: z$1.number().nullish(),
+		subagent: z$1.string().nullish(),
+		background_tasks: z$1.number().int().min(0).nullish()
+	}).nullish()
+});
+//#endregion
 //#region ../../b4m-core/common/dist/index.mjs
 let HttpStatus = /* @__PURE__ */ function(HttpStatus) {
 	HttpStatus[HttpStatus["Ok"] = 200] = "Ok";
@@ -148,9 +285,11 @@ let HttpStatus = /* @__PURE__ */ function(HttpStatus) {
 	HttpStatus[HttpStatus["Unauthorized"] = 401] = "Unauthorized";
 	HttpStatus[HttpStatus["Forbidden"] = 403] = "Forbidden";
 	HttpStatus[HttpStatus["NotFound"] = 404] = "NotFound";
+	HttpStatus[HttpStatus["Conflict"] = 409] = "Conflict";
 	HttpStatus[HttpStatus["UnprocessableEntity"] = 422] = "UnprocessableEntity";
 	HttpStatus[HttpStatus["TooManyRequests"] = 429] = "TooManyRequests";
 	HttpStatus[HttpStatus["InternalServerError"] = 500] = "InternalServerError";
+	HttpStatus[HttpStatus["BadGateway"] = 502] = "BadGateway";
 	return HttpStatus;
 }({});
 var HTTPError = class extends Error {
@@ -277,6 +416,7 @@ let ApiKeyType = /* @__PURE__ */ function(ApiKeyType) {
 	ApiKeyType["ollama"] = "ollama";
 	ApiKeyType["xai"] = "xai";
 	ApiKeyType["kimi"] = "kimi";
+	ApiKeyType["deepseek"] = "deepseek";
 	ApiKeyType["voyageai"] = "voyageai";
 	return ApiKeyType;
 }({});
@@ -312,6 +452,7 @@ const b4mLLMTools = z$1.enum([
 	"chess_engine",
 	"retrieve_knowledge_content",
 	"count_knowledge_base",
+	"describe_knowledge_base",
 	"delegate_to_agent",
 	"optihashi_schedule",
 	"optihashi_formulate",
@@ -349,6 +490,16 @@ const FallbackInfoSchema = z$1.object({
 	primaryModelName: z$1.string(),
 	fallbackModel: z$1.string(),
 	fallbackModelName: z$1.string(),
+	/**
+	* Backend of each side, so the badge can name the provider path without
+	* inferring it from the id - a bare `deepseek-*` slug is the direct API on a
+	* hosted deployment and an Ollama pull on a self-hosted one. Optional and
+	* loosely typed: these payloads are persisted in browser storage, so a record
+	* written by an older build has neither field and an unknown backend name from
+	* a newer one must not fail the parse.
+	*/
+	primaryModelBackend: z$1.string().optional(),
+	fallbackModelBackend: z$1.string().optional(),
 	timestamp: z$1.number()
 });
 const ArtifactMetadataSchema = z$1.object({
@@ -755,6 +906,7 @@ let ModelBackend = /* @__PURE__ */ function(ModelBackend) {
 	ModelBackend["BFL"] = "bfl";
 	ModelBackend["XAI"] = "xai";
 	ModelBackend["Kimi"] = "kimi";
+	ModelBackend["DeepSeek"] = "deepseek";
 	ModelBackend["VoyageAI"] = "voyageai";
 	ModelBackend["AWS"] = "aws";
 	ModelBackend["LocalImage"] = "local-image";
@@ -785,6 +937,62 @@ let ImageModels = /* @__PURE__ */ function(ImageModels) {
 Object.values(ImageModels);
 z$1.enum(ImageModels);
 /**
+* Image size constraints and options
+*/
+const IMAGE_SIZE_CONSTRAINTS = {
+	BFL: {
+		minWidth: 256,
+		maxWidth: 1440,
+		minHeight: 256,
+		maxHeight: 1440,
+		stepSize: 32,
+		defaultSize: "1280x960",
+		sizes: [
+			"1280x960",
+			"1024x768",
+			"800x600",
+			"1280x720",
+			"1024x576",
+			"1440x810",
+			"1024x1024",
+			"768x768",
+			"512x512",
+			"960x1280",
+			"768x1024",
+			"600x800"
+		]
+	},
+	GPT_IMAGE_1: {
+		sizes: [
+			"1024x1024",
+			"1024x1536",
+			"1536x1024"
+		],
+		defaultSize: "1024x1024"
+	},
+	GPT_IMAGE_2: {
+		/** Popular preset sizes shown in the UI. The API accepts any resolution meeting the constraints. */
+		sizes: [
+			"1024x1024",
+			"1536x1024",
+			"1024x1536",
+			"2048x2048",
+			"2048x1152",
+			"3840x2160",
+			"2160x3840"
+		],
+		defaultSize: "1024x1024",
+		/** Constraints for custom/flexible sizes */
+		constraints: {
+			maxEdge: 3840,
+			minTotalPixels: 655360,
+			maxTotalPixels: 8294400,
+			edgeMultiple: 16,
+			maxAspectRatio: 3
+		}
+	}
+};
+/**
 * Chat Models
 *
 * https://platform.openai.com/docs/models/continuous-model-upgrades
@@ -897,6 +1105,7 @@ let ChatModels = /* @__PURE__ */ function(ChatModels) {
 	ChatModels["KIMI_K2_5"] = "kimi-k2.5";
 	ChatModels["KIMI_K2_5_BEDROCK"] = "moonshotai.kimi-k2.5";
 	ChatModels["KIMI_K2_THINKING_BEDROCK"] = "moonshot.kimi-k2-thinking";
+	ChatModels["DEEPSEEK_FLASH"] = "deepseek-flash";
 	return ChatModels;
 }({});
 const CHAT_MODELS = Object.values(ChatModels);
@@ -1031,7 +1240,8 @@ const NO_TEMPERATURE_MODELS = /* @__PURE__ */ new Set([
 	"kimi-k2.7-code",
 	"kimi-k2.7-code-highspeed",
 	"kimi-k2.6",
-	"kimi-k2.5"
+	"kimi-k2.5",
+	"deepseek-flash"
 ]);
 /**
 * Models whose safety classifiers can decline a request with `stop_reason: 'refusal'`
@@ -1122,6 +1332,14 @@ const SUBQUEST_STATUS_VALUES = [
 	"deleted"
 ];
 /**
+* Status of a review gate on a sub-quest
+*/
+const REVIEW_GATE_STATUS_VALUES = [
+	"pending",
+	"approved",
+	"rejected"
+];
+/**
 * Valid complexity ratings for quests.
 * Canonical vocabulary - matches what the planner generates and validates
 * (Easy < 1 hour, Medium 1-4 hours, Hard > 4 hours).
@@ -1512,6 +1730,7 @@ const ADAPTER_FAMILIES = [
 	"gemini",
 	"xai",
 	"kimi",
+	"deepseek",
 	"ollama",
 	"bfl",
 	"local-image",
@@ -1762,6 +1981,7 @@ const MODEL_INFO_FIELD_GROUP_OF = {
 	supportsImageVariation: "modalities",
 	supportsSafetyTolerance: "modalities",
 	deprecationDate: "lifecycle",
+	replacedBy: "lifecycle",
 	adapterFamily: "dispatch",
 	dispatchProfile: "dispatch",
 	description: "presentation",
@@ -1885,6 +2105,8 @@ z$1.object({
 	}).optional(),
 	/** Optional: a state row written before Phase 4 has none, and must keep parsing. */
 	suggestion: ModelLifecycleSuggestion.optional(),
+	/** Dispatch probes spent on this model, so one that always fails stops taking a budget slot. */
+	probeAttempts: z$1.number().int().nonnegative().optional(),
 	createdAt: z$1.date(),
 	updatedAt: z$1.date()
 });
@@ -2188,6 +2410,13 @@ z$1.object({
 	createdAt: z$1.date(),
 	updatedAt: z$1.date()
 });
+let McpServerName = /* @__PURE__ */ function(McpServerName) {
+	McpServerName["LinkedIn"] = "linkedin";
+	McpServerName["Github"] = "github";
+	McpServerName["Atlassian"] = "atlassian";
+	McpServerName["Notion"] = "notion";
+	return McpServerName;
+}({});
 /**
 * Check if a value is a placeholder (not configured or SST default).
 * Uses case-insensitive comparison and trims whitespace to prevent bypass attempts.
@@ -2233,6 +2462,42 @@ function isPlaceholderApiKey(value) {
 	if (!normalized) return true;
 	return PLACEHOLDER_API_KEY_REGEX.test(normalized);
 }
+/**
+* Lake lifecycle. Stable states (draft/active/archived/deleted) plus transitional
+* states (archiving/unarchiving/restoring/deleting/purging) that exist to drive UI and make a crashed
+* mid-operation observable. draft -> active is one-way. It happens implicitly once the lake
+* holds its first member file (see `activateIfDraft` below), and unconditionally when an
+* archived or deleted lake is restored, which is how an empty lake can end up active.
+*
+* `purging` is the one transitional state that is NOT recoverable by retrying the same action:
+* it is claimed the moment a phase-2 hard delete is ACCEPTED (#1744), before the background
+* sweep runs, so that `listDeletedDataLakes` stops offering Restore on a lake whose
+* destruction is already irreversible. Everything else that reads `status` must treat it as
+* "going away", never as a lake to act on.
+*/
+const DATA_LAKE_STATUSES = [
+	"draft",
+	"active",
+	"archiving",
+	"archived",
+	"unarchiving",
+	"restoring",
+	"deleting",
+	"deleted",
+	"purging"
+];
+/**
+* Stable (non-transitional) lake statuses - a lake sitting in one of these is at rest, not
+* mid-operation. Load-bearing as the INPUT to `DATA_LAKE_TRANSITIONAL_STATUSES` below, which is
+* what drives the needs-attention list; it is not itself a filter any list path applies.
+*/
+const DATA_LAKE_STABLE_STATUSES = [
+	"draft",
+	"active",
+	"archived",
+	"deleted"
+];
+DATA_LAKE_STATUSES.filter((s) => !DATA_LAKE_STABLE_STATUSES.includes(s));
 z$1.object({
 	/**
 	* The granting lake's Mongo `_id`. ALWAYS a persisted DB lake: a hardcoded/fallback lake has no
@@ -2263,6 +2528,23 @@ z$1.object({
 	*/
 	expiresAt: z$1.date().nullish()
 });
+/** One prefix-arm content tag a lake held on a file, as captured at removal for later restore. */
+const LakeMembershipRemovalContentTag = z$1.object({
+	name: z$1.string(),
+	strength: z$1.number()
+});
+z$1.object({
+	dataLakeId: z$1.string(),
+	fabFileId: z$1.string(),
+	/** The principal who performed the removal - audit only, never a restore authorization input. */
+	actorUserId: z$1.string(),
+	/** The lake's prefix-arm tags the file carried, captured by `lakeMembershipSignals`. May be
+	*  empty - a meta-tag-only member and a non-creator-owned file both removed with no content
+	*  tags to restore, which is a complete and legitimate answer, not "nothing to record". */
+	contentTags: z$1.array(LakeMembershipRemovalContentTag),
+	removedAt: z$1.date(),
+	expiresAt: z$1.date()
+});
 /**
 * Every `IDataLake` field, classified as audited or not. A TOTAL map keyed by `keyof IDataLake`,
 * exactly like `LAKE_FIELD_VISIBILITY` in redactLakeForActor.ts and for the same reason: a list of
@@ -2289,6 +2571,7 @@ const LAKE_CONFIG_FIELD_AUDIT = {
 	organizationId: "audited",
 	isPublic: "audited",
 	auditQueryTextEnabled: "audited",
+	lakeMemoryEnabled: "audited",
 	status: "audited",
 	createdByUserId: "audited",
 	lastUpdatedByUserId: "excluded",
@@ -2300,7 +2583,10 @@ const LAKE_CONFIG_FIELD_AUDIT = {
 	filesDeletedAt: "excluded",
 	filesArchivedAt: "excluded",
 	lakeMemoryExtractionAt: "excluded",
-	lakeMemoryCursor: "excluded"
+	lakeMemoryCursor: "excluded",
+	lakeMemoryPurgedAt: "excluded",
+	inconsistencyReport: "excluded",
+	inconsistencyComputedAt: "excluded"
 };
 [...Object.keys(LAKE_CONFIG_FIELD_AUDIT).filter((field) => LAKE_CONFIG_FIELD_AUDIT[field] === "audited")];
 /**
@@ -2862,6 +3148,7 @@ function toModelInfo(record) {
 		disabled,
 		disabledReason: record.disabledReason ?? record.autoDisabledReason ?? (retired ? "retired by the provider" : void 0),
 		deprecationDate: record.lifecycle?.deprecationDate,
+		replacedBy: record.lifecycle?.replacedBy,
 		trainingCutoff: record.trainingCutoff,
 		releaseDate: record.releaseDate,
 		logoFile: record.logoFile,
@@ -2894,6 +3181,7 @@ const VENDOR_BY_BACKEND = {
 	["gemini"]: "google",
 	["xai"]: "xai",
 	["kimi"]: "moonshotai",
+	["deepseek"]: "deepseek",
 	["bfl"]: "black-forest-labs",
 	["aws"]: "amazon",
 	["voyageai"]: "voyageai",
@@ -2962,10 +3250,13 @@ function toModelRecord(info) {
 		supportsTools: info.supportsTools,
 		supportsImageVariation: info.supportsImageVariation,
 		supportsSafetyTolerance: info.supportsSafetyTolerance,
-		lifecycle: info.deprecationDate ? {
-			status: "deprecated",
-			deprecationDate: info.deprecationDate
-		} : { status: "active" },
+		lifecycle: {
+			...info.deprecationDate ? {
+				status: "deprecated",
+				deprecationDate: info.deprecationDate
+			} : { status: "active" },
+			...info.replacedBy ? { replacedBy: info.replacedBy } : {}
+		},
 		description: info.description,
 		logoFile: info.logoFile,
 		rank: info.rank,
@@ -3094,6 +3385,71 @@ const usdToCreditsStochastic = (usd, rng = cryptoUniform, rate = CREDITS_PER_USD
 	const fraction = raw - base;
 	return base + (rng() < fraction ? 1 : 0);
 };
+/**
+* Output tokens the pre-flight credit hold prices when a request's max_tokens
+* ceiling exceeds it.
+*
+* max_tokens is a *ceiling*, not a prediction: adaptive reasoning models stop at
+* end_turn well short of it, so pricing the hold at the full window (128K on the
+* flagship models) reserved several thousand credits per turn regardless of answer
+* length. The excess was always refunded at settlement, but the hold IS the
+* insufficient-funds gate, so users whose balance sat between their real cost and
+* the worst case were falsely blocked.
+*
+* 16K covers the realistic long answer with headroom - the largest replies seen in
+* practice are HTML-artifact turns at roughly 10-11K output tokens (see
+* buildThinkingParams in llm-adapters/thinkingParams.ts, whose max_tokens floor was
+* sized off the same measurement).
+*
+* UNDER-RESERVATION IS ACCEPTED, NOT PREVENTED. A turn that emits more than this
+* settles as a shortfall debit at reconciliation, which is already a supported path
+* (provider-basis settlement could always exceed a hold priced on the local
+* estimate). The two sites clamp the shortfall differently: chat's
+* computeSettlementDelta (services/llm/ChatCompletionProcess.ts) floors the debit at
+* the balance snapshot taken at its OWN admission and reports the remainder as
+* writtenOffCredits; cliCompletions.ts does an unclamped $inc on success and only
+* logs an ALERT if it lands negative. Neither is a non-negativity guarantee: the
+* chat snapshot predates any sibling turn's spend (see that function's own "best
+* effort" note), and when the shortfall still fits the stale snapshot the debit
+* applies in full - writtenOffCredits 0, and no BILLING_SHORTFALL_CLAMP log - so a
+* concurrent holder can land negative there too. Either way the resulting balance
+* fails the *next* turn's own admission gate - but that bound is per turn, not per
+* holder: turns admitted concurrently are each checked against the balance at their
+* own admission and settle against a snapshot that predates their siblings' spend,
+* so a holder running turns in parallel can be shorted once per in-flight turn, not
+* once total.
+*/
+const PREFLIGHT_RESERVATION_OUTPUT_TOKENS = 16384;
+/**
+* Reservation ceiling for models that spend reasoning tokens inside their output
+* budget (see reasonsWithinOutputBudget in llm-adapters/thinkingParams.ts). Those
+* tokens bill as output on top of the visible answer, so the 16K figure above -
+* which was measured on visible artifact size alone - under-reserves them badly.
+*
+* Deliberately below ADAPTIVE_THINKING_MAX_TOKENS_FLOOR (64K), which sizes the
+* request's real ceiling and therefore has to cover the worst case: exceeding it
+* truncates a reply mid-tag, an unrecoverable failure. A hold has no such duty -
+* exceeding it settles as a shortfall debit - so it is sized for the long turn
+* (roughly 3x the largest observed visible answer, leaving the rest for the trace)
+* rather than the worst one, which is what keeps the gate off affordable requests.
+*/
+const PREFLIGHT_RESERVATION_REASONING_OUTPUT_TOKENS = 32768;
+/**
+* Output-token figure to price a pre-flight credit hold at, given the max_tokens
+* this request will actually send. Never raises the caller's ceiling: a request
+* that asks for less than the cap holds only what it can possibly spend.
+*
+* Reserving only, never gating: the per-member org credit cap is still priced on
+* the unshrunk ceiling at both call sites, since that check has no settlement
+* counterpart to correct an under-estimate. That is a strictly larger figure than
+* the hold, not a true upper bound on the turn - it prices one model round trip,
+* at the uncached input rate, on the primary model - so it still under-counts a
+* multi-round tool loop, a cache-write turn, or a fallback hop onto pricier pricing.
+*
+* @param reasonsWithinOutputBudget - reasonsWithinOutputBudget(modelInfo); passed as
+*   a boolean because common cannot import llm-adapters.
+*/
+const reservationOutputTokens = (requestedMaxTokens, reasonsWithinOutputBudget = false) => Math.min(requestedMaxTokens, reasonsWithinOutputBudget ? PREFLIGHT_RESERVATION_REASONING_OUTPUT_TOKENS : PREFLIGHT_RESERVATION_OUTPUT_TOKENS);
 z.enum([
 	"openai",
 	"test",
@@ -3101,6 +3457,58 @@ z.enum([
 	"xai",
 	"gemini"
 ]);
+z$1.enum([
+	"inject",
+	"auto-fire",
+	"hidden"
+]);
+/**
+* Modes acceptable at AUTHORING time. 'hidden' is intentionally excluded until
+* the host has true hidden-send support - accepting it would persist a value
+* that silently behaves as 'auto-fire' (a surprising downgrade). It stays in
+* ExecutionModeSchema/the stored enum for forward-compat.
+*/
+const AuthorableExecutionModeSchema = z$1.enum(["inject", "auto-fire"]);
+/**
+* Tools a prompt may require - constrained to the host's closed tool set, MINUS
+* integration-gated tools that act on the caller's own credentials/account. A
+* shared system prompt must not be able to inject e.g. blog-publishing into a
+* non-author's session via requiredTools. (Per-user entitlement of the remaining
+* tools is still the chat pipeline's responsibility - see follow-up note in the
+* briefcase blueprint; this allowlist is the storage-layer floor.)
+*/
+const BRIEFCASE_DISALLOWED_TOOLS = [
+	"blog_publish",
+	"blog_edit",
+	"blog_draft"
+];
+const BriefcaseRequiredToolsSchema = z$1.array(b4mLLMTools.refine((t) => !BRIEFCASE_DISALLOWED_TOOLS.includes(t), "This tool is not permitted in a briefcase prompt")).max(16);
+z$1.string().regex(/^[a-f0-9]{24}$/i, "Invalid prompt id");
+/** Shared cap for every free-text prompt body a caller can supply. Exported so the
+* caller-prompt caps on the chat request, the invoke params and the CLI tool import it
+* rather than each restating the literal. */
+const PROMPT_TEXT_MAX = 16e3;
+const TAGS_MAX = 20;
+z$1.object({
+	type: z$1.string().min(1).max(100),
+	name: z$1.string().min(1).max(200),
+	description: z$1.string().max(500).optional(),
+	promptText: z$1.string().min(1).max(PROMPT_TEXT_MAX),
+	tags: z$1.array(z$1.string().min(1).max(50)).max(TAGS_MAX).optional(),
+	executionMode: AuthorableExecutionModeSchema.optional(),
+	requiredTools: BriefcaseRequiredToolsSchema.optional()
+}).partial();
+/**
+* One catalog sub-query. Exactly one selector is used, in precedence order:
+* `personal` (resolved to the caller server-side) > `tags` > `type`.
+*/
+const PromptBatchQuerySchema = z$1.object({
+	key: z$1.string().min(1).max(100),
+	tags: z$1.array(z$1.string().min(1).max(50)).max(TAGS_MAX).optional(),
+	type: z$1.string().max(100).optional(),
+	personal: z$1.boolean().optional()
+});
+z$1.object({ queries: z$1.array(PromptBatchQuerySchema).min(1).max(32).refine((qs) => new Set(qs.map((q) => q.key)).size === qs.length, { message: "Batch query keys must be unique" }) });
 z$1.object({
 	sessionId: z$1.string().nullish(),
 	message: z$1.string(),
@@ -3116,7 +3524,7 @@ z$1.object({
 	wait: z$1.boolean().prefault(false),
 	enableTools: z$1.boolean().prefault(false),
 	toolMode: z$1.enum(["fast", "smart"]).optional(),
-	tools: z$1.array(z$1.string()).optional(),
+	tools: z$1.array(z$1.string()).optional().describe("Explicit tool ids to offer the model. A non-empty array enables tools on its own; no companion `toolMode` or `enableTools` is required. Merged with the auto-selected set under `toolMode: \"smart\"`, and ignored under `toolMode: \"fast\"`. This list ADDS to what is offered rather than restricting it - the server still offers tools of its own (for example knowledge retrieval when the session has reachable documents). Unrecognized ids are dropped rather than rejecting the request; the response reports the surviving set as `tools.effectiveTools` and the ids that are not tools in this deployment as `tools.unrecognizedTools`, since no endpoint enumerates the valid ids. `unrecognizedTools` is reported under every `toolMode` - it describes the ids, not what the mode did with them - so under `toolMode: \"fast\"` an id can be absent from `effectiveTools` (the mode discarded it) without being unrecognized. Both reported lists are deduplicated, and `unrecognizedTools` names at most the first 10 distinct ids."),
 	enableQuestMaster: z$1.boolean().optional(),
 	enableMementos: z$1.boolean().optional(),
 	enableAgents: z$1.boolean().optional(),
@@ -3125,8 +3533,10 @@ z$1.object({
 		"grounded",
 		"surface"
 	]).optional(),
+	skip_auto_offers: z$1.boolean().optional().describe("Suppress tools the server would otherwise attach on its own for this session (the knowledge-base search offer, in-app view navigation, blog drafting/editing/publishing, and skill invocation). Tools you request explicitly are unaffected. One system-prompt block goes with them: withholding in-app view navigation also drops the view-registry block that exists only to describe it. No other prompt content changes. This does not switch off retrieval: a session with forced knowledge retrieval still retrieves, and documents already attached to the session are still placed in the prompt directly. Any promptMode suppresses these too, so false has no effect alongside one."),
 	includePromptDetails: z$1.boolean().optional(),
-	includeSystemPrompt: z$1.boolean().optional()
+	includeSystemPrompt: z$1.boolean().optional(),
+	systemPrompt: z$1.string().max(PROMPT_TEXT_MAX).optional().describe("System-prompt text for this request only, never persisted. Rendered as a defended block appended after every other system-prompt source, with prose instructing the model to defer to organization, session and data-lake guidance. Over the cap is a 422, never truncated.")
 });
 z$1.object({
 	id: z$1.string(),
@@ -3135,6 +3545,12 @@ z$1.object({
 	timestamp: z$1.string(),
 	model: z$1.string(),
 	message: z$1.string().optional(),
+	tools: z$1.object({
+		toolMode: z$1.enum(["fast", "smart"]).optional(),
+		autoSelectedTools: z$1.array(z$1.string()).optional(),
+		effectiveTools: z$1.array(z$1.string()),
+		unrecognizedTools: z$1.array(z$1.string()).optional()
+	}).optional(),
 	tracking_info: z$1.object({
 		quest_id: z$1.string(),
 		check_status_url: z$1.string(),
@@ -3357,13 +3773,93 @@ const AGENT_EXECUTION_STATUSES = [
 	"failed",
 	"aborted"
 ];
+/**
+* Operator allow-list for the client-authored Mongo filter carried on a `subscribe_query` frame.
+*
+* The WS data-subscribe handler forwards that filter to `Model.find` and persists it on the
+* QuerySubscription the separate subscriber-fanout service replays, so an unconstrained
+* `$`-prefixed key lets any authenticated socket ask the database to run server-side JavaScript
+* (`$where`, `$expr` + `$function`) or an unbounded `$regex` - either of which pins a pooled
+* connection for as long as it runs.
+*
+* Live subscriptions only ever need equality, membership and range matching, so anything outside
+* this list is REFUSED rather than stripped: silently dropping an operator would quietly widen the
+* document set the caller ends up subscribed to.
+*
+* The scan is deliberately structural rather than a model of Mongo's grammar - it flags any
+* `$`-prefixed key anywhere in the tree that isn't allow-listed. It can therefore accept an
+* allow-listed operator in a position Mongo would treat as a literal sub-document field name, but
+* that is inert; what matters is that no disallowed operator can reach the driver.
+*/
+/** Combinators whose operands are themselves filters. */
+const SUBSCRIPTION_FILTER_LOGICAL_OPERATORS = [
+	"$and",
+	"$or",
+	"$nor",
+	"$not"
+];
+/** Value-level operators a subscription filter may use. */
+const SUBSCRIPTION_FILTER_VALUE_OPERATORS = [
+	"$eq",
+	"$ne",
+	"$gt",
+	"$gte",
+	"$lt",
+	"$lte",
+	"$in",
+	"$nin",
+	"$exists",
+	"$type",
+	"$size",
+	"$all",
+	"$elemMatch"
+];
+const ALLOWED_OPERATORS = /* @__PURE__ */ new Set([...SUBSCRIPTION_FILTER_LOGICAL_OPERATORS, ...SUBSCRIPTION_FILTER_VALUE_OPERATORS]);
+/**
+* Returns a dotted path for every part of `filter` a subscription may not send: a disallowed
+* `$`-prefixed key, a `RegExp` operand, or nesting past {@link SUBSCRIPTION_FILTER_MAX_DEPTH}.
+* An empty array means the filter is safe to forward to the database.
+*/
+function findDisallowedSubscriptionFilterKeys(filter) {
+	const violations = [];
+	const walk = (node, path, depth) => {
+		if (depth > 12) {
+			violations.push(`${path} (nested deeper than 12)`);
+			return;
+		}
+		if (node instanceof RegExp) {
+			violations.push(`${path} (regular expression)`);
+			return;
+		}
+		if (Array.isArray(node)) {
+			node.forEach((entry, i) => walk(entry, `${path}[${i}]`, depth + 1));
+			return;
+		}
+		if (node === null || typeof node !== "object") return;
+		for (const [key, value] of Object.entries(node)) {
+			const childPath = path ? `${path}.${key}` : key;
+			if (key.startsWith("$") && !ALLOWED_OPERATORS.has(key)) {
+				violations.push(childPath);
+				continue;
+			}
+			walk(value, childPath, depth + 1);
+		}
+	};
+	walk(filter, "", 0);
+	return violations;
+}
 const DataSubscribeRequestAction = z$1.object({
 	action: z$1.literal("subscribe_query"),
 	accessToken: z$1.string().optional(),
 	subscriptionId: z$1.string(),
 	collectionName: z$1.string(),
-	query: z$1.looseObject({}),
-	fields: z$1.looseObject({}),
+	query: z$1.looseObject({}).superRefine((filter, ctx) => {
+		for (const key of findDisallowedSubscriptionFilterKeys(filter)) ctx.addIssue({
+			code: "custom",
+			message: `Disallowed subscription filter: ${key}`
+		});
+	}),
+	fields: z$1.record(z$1.string(), z$1.union([z$1.boolean(), z$1.number()])),
 	fetchInitialData: z$1.boolean().prefault(true).optional(),
 	clientId: z$1.string().optional()
 });
@@ -3450,6 +3946,17 @@ const DataSubscriptionUpdateAction = z$1.object({
 		id: z$1.string()
 	})
 });
+/**
+* Server -> Client: a `subscribe_query` frame was refused (the operator allow-list, `fields`
+* validation) or its initial fetch was aborted (`maxTimeMS`). Neither failure throws an
+* UnauthorizedError/JsonWebTokenError, so withWebSocketContext's status code never reaches the
+* client as a frame - this is the only signal the caller gets that the subscription never took.
+*/
+const DataSubscribeErrorAction = z$1.object({
+	action: z$1.literal("data_subscribe_error"),
+	subscriptionId: z$1.string(),
+	error: z$1.string()
+});
 const LLMStatusUpdateAction = z$1.object({
 	action: z$1.literal("llm_status_update"),
 	status: z$1.string().nullable(),
@@ -3532,6 +4039,7 @@ const QuestExportProgressAction = z$1.object({
 	downloadUrl: z$1.string().optional(),
 	filename: z$1.string().optional(),
 	errorMessage: z$1.string().optional(),
+	droppedQuestCount: z$1.number().optional(),
 	clientId: z$1.string().optional()
 });
 const SpiderProgressUpdateAction = z$1.object({
@@ -4682,6 +5190,7 @@ const OptiHashiRunUpdatedAction = z$1.object({
 });
 z$1.discriminatedUnion("action", [
 	DataSubscriptionUpdateAction,
+	DataSubscribeErrorAction,
 	InboxRefetchAction,
 	LLMStatusUpdateAction,
 	InvitesRefetchAction,
@@ -4739,6 +5248,126 @@ z$1.discriminatedUnion("action", [
 	PermissionRequestAction,
 	ReconnectResultAction
 ]);
+z$1.object({
+	session_id: z$1.string().min(1),
+	message: z$1.string().min(1),
+	/** Falls back to the deployment's default chat model when omitted. */
+	model: z$1.string().optional(),
+	/**
+	* Run as a specific persisted agent. Omit to let the executor pick the profile for
+	* the session: a session on a dedicated surface gets that surface's own profile,
+	* otherwise a synthetic one built from admin orchestration defaults. Omitting this
+	* is what reproduces the product UI's Agent Mode toggle.
+	*/
+	agent_id: z$1.string().optional(),
+	/**
+	* Bill this run to an organization's credit pool. The caller must belong to it; a
+	* non-member gets 404. Omit to bill the caller personally.
+	*/
+	organization_id: z$1.string().optional(),
+	/**
+	* Tool-id allowlist for the run. Omit to use the resolved profile's own list.
+	*
+	* Doubles as pre-approval: REST runs have no interactive client to answer a
+	* permission prompt, so tools named here are treated as approved. A run that calls
+	* an approval-gated tool NOT named here fails with that tool named in `error`.
+	*/
+	tools: z$1.array(z$1.string()).optional(),
+	/**
+	* Hard ceiling on ReAct iterations. Each one is a full LLM round-trip, so the cap is
+	* bounded at 100 regardless of what the profile would allow.
+	*/
+	max_iterations: z$1.number().int().positive().max(100).optional(),
+	temperature: z$1.number().min(0).max(2).optional(),
+	max_tokens: z$1.number().int().positive().optional(),
+	thinking: z$1.object({
+		enabled: z$1.boolean(),
+		/** Bounded at 32000: Anthropic rejects rather than clamps an oversized budget. */
+		budget_tokens: z$1.number().int().positive().max(32e3).optional()
+	}).optional(),
+	/** Per-message file attachments (fabFile ids), materialized into the first iteration. */
+	file_ids: z$1.array(z$1.string()).optional(),
+	/** Workbench-level file ids for the session, forwarded as a dispatch-time snapshot. */
+	session_file_ids: z$1.array(z$1.string()).optional(),
+	enable_mementos: z$1.boolean().optional(),
+	enable_lattice: z$1.boolean().optional(),
+	/**
+	* Opt out of the artifact-emission prompt and artifact persistence for this run.
+	*
+	* ANDed with the deployment's admin `EnableArtifacts` setting, so this can only ever
+	* withhold artifacts, never force them on. Omitting it means "no preference" and
+	* leaves the admin setting as the only gate; only an explicit `false` opts out.
+	* Inherited by any subagent this run dispatches, so a delegating agent cannot route
+	* around the opt-out.
+	*
+	* Worth setting on a REST run: the emission prompt costs roughly 2.8k tokens per
+	* iteration, and nothing on this transport renders an artifact back to a human.
+	*/
+	enable_artifacts: z$1.boolean().optional()
+});
+z$1.object({
+	id: z$1.string(),
+	status: z$1.literal("pending"),
+	session_id: z$1.string(),
+	model: z$1.string(),
+	timestamp: z$1.string(),
+	tracking_info: z$1.object({
+		execution_id: z$1.string(),
+		/**
+		* The chat-history Quest holding the prompt, which gains the reply when the run
+		* completes. Absent when that best-effort write failed; the run still proceeds.
+		*/
+		quest_id: z$1.string().optional(),
+		poll_url: z$1.string()
+	})
+});
+/** One step of a published reasoning trace - a public projection of `IAgentStep`. */
+const AgentExecutionStepSchema = z$1.object({
+	type: z$1.enum([
+		"thought",
+		"action",
+		"observation",
+		"final_answer"
+	]),
+	content: z$1.string(),
+	/** 0-indexed iteration. Absent on traces checkpointed before the field existed. */
+	iteration: z$1.number().int().nonnegative().optional(),
+	/** Set on `action` steps: the tool the agent invoked. */
+	tool_name: z$1.string().optional()
+});
+z$1.object({
+	id: z$1.string(),
+	status: z$1.enum([
+		"pending",
+		"running",
+		"continuing",
+		"awaiting_permission",
+		"awaiting_subagent",
+		"awaiting_dag_children",
+		"paused",
+		"completed",
+		"failed",
+		"aborted"
+	]),
+	session_id: z$1.string().nullable(),
+	answer: z$1.string().nullable(),
+	/**
+	* Why the run ended without an answer. Set only on `failed`; null otherwise.
+	* Without this a caller polling a terminal run sees `failed` + a null answer and
+	* cannot tell an approval-gated tool from a model error from a timeout.
+	*
+	* Approval-gate failures name the offending tool, since that is what the caller acts
+	* on. Everything else is reduced to a coarse category (billing, rate limit, timeout,
+	* auth) or a generic message: the stored reason is a raw internal exception, and
+	* those carry infrastructure identifiers. Full detail stays in the server logs.
+	*/
+	error: z$1.string().nullable(),
+	steps: z$1.array(AgentExecutionStepSchema),
+	total_iterations: z$1.number().nullable(),
+	created_at: z$1.string(),
+	updated_at: z$1.string()
+});
+z$1.object({ id: z$1.string().min(1) });
 /**
 * Tool schema matching ICompletionOptionTools.toolSchema. The Zod surface only
 * covers wire-format fields (toolFn is server-side). Replaces the historical
@@ -5813,43 +6442,129 @@ z$2.object({
 */
 const OVERSIZED_PASSAGE_TOKEN_THRESHOLD = 1500;
 /**
-* `FabFile.notes` marker written when the data-lake convergence kill switch abandons a vectorize
-* (#1676). The file keeps its chunks but has no vectors, so it is unsearchable until re-indexed, and
-* it does NOT auto-resume.
+* Why a file's chunk/vector pipeline is STALLED, stored in `FabFile.chunkStallReason`.
+*
+*  - `vectorizePaused`: the data-lake convergence kill switch abandoned a vectorize (#1676). The
+*    file keeps its chunks but has no vectors, so it is unsearchable until re-indexed.
+*  - `rechunkPaused`: the OTHER half of the same switch dropped a re-chunk before it ran
+*    (#1676/#1681). The damage is worse - the producer resets a wave's chunk state BEFORE the
+*    messages are handled, so a file halted here has NO chunks at all.
+*  - `unchunkedPaused`: the same chunk half, on a file that never had passages to lose. The rescue
+*    sweep selects on `chunkCount: 0` and enqueues without resetting anything, so a file it routes
+*    into the halt branch arrives already empty. The halted STATE is identical to `rechunkPaused`
+*    and every reader keys on both (CHUNKLESS_STALL_REASONS) - the split exists so the owner is not
+*    told that passages were removed which never existed.
+*
+* None auto-resumes; each needs a reprocess or a lifted switch.
 *
-* Lives here rather than beside its writer (apps/client fabFileVectorize) because it is a
-* cross-layer contract: the queue handler writes it and the lake-health evaluator
-* (constants/lakeHealth.ts) reads it to tell a permanently-stalled file from one still in flight.
-* b4m-core cannot import from apps/client, so a copy there would have to drift silently.
+* Without a marker the state is misread by every surface at once, which is the failure the field
+* exists to prevent: `chunkCount: 0` with `error: null` reads as an image or a pending upload, so
+* health drops it from the denominator, convergence grades it `conformant` (its stale stamp still
+* matches), and search does not withhold it because it is not "in flight". The file's passages are
+* simply gone and nothing REPORTS it. The rescue sweep is the one exception and deliberately so: an
+* unmarked file matches its filter and gets re-chunked, which is repair rather than reporting. That
+* is why the sweep excludes a stalled file only while the switch is ON - see
+* buildFabFileChunkScanFilter.
+*
+* A dedicated field rather than prose in `FabFile.notes` (#2016): `notes` is the USER's note, and
+* while the markers lived there every writer of the field clobbered the others - a "Rebuild
+* passages" wave silently deleted whatever the owner had typed.
+*
+* Lives here rather than beside its writers (apps/client's chunk and vectorize handlers) because it
+* is a cross-layer contract: the queue handlers write it and b4m-core's evaluators
+* (constants/lakeHealth.ts, constants/lakeConvergence.ts, dataLakeService/retrievalUnavailable.ts)
+* read it to tell a permanently-stalled file from one still in flight. b4m-core cannot import from
+* apps/client, so a copy there would have to drift silently.
+*/
+const CHUNK_STALL_REASONS = [
+	"vectorizePaused",
+	"rechunkPaused",
+	"unchunkedPaused"
+];
+/**
+* Whether a file is stalled by the convergence kill switch, by any arm. THE predicate every
+* reader uses, so adding a stall reason reaches health, convergence and retrieval without separate
+* comparisons drifting apart. Also the in-memory mirror of a Mongo
+* `chunkStallReason: { $in: [...CHUNK_STALL_REASONS] }`.
 */
-const CONVERGENCE_PAUSED_NOTE = "Indexing paused by the data-lake convergence kill switch - reprocess to complete.";
+function isChunkStalled(reason) {
+	return CHUNK_STALL_REASONS.includes(reason);
+}
 /**
-* `FabFile.notes` marker for the OTHER half of the same kill switch: a re-chunk dropped before it
-* ran (#1676/#1681). Distinct from `CONVERGENCE_PAUSED_NOTE` because the damage is worse and the
-* wording has to say so - the producer resets a wave's chunk state BEFORE the messages are handled,
-* so a file halted here has NO chunks at all rather than chunks without vectors.
+* Which reasons leave the file with NO passages, as opposed to passages with no vectors. A `Record`
+* over every reason rather than a hand-written subset array: a new stall reason then cannot compile
+* until it is classified, where a member missing from a literal array would just make a health count
+* silently wrong.
+*/
+const STALL_LEAVES_NO_PASSAGES = {
+	vectorizePaused: false,
+	rechunkPaused: true,
+	unchunkedPaused: true
+};
+CHUNK_STALL_REASONS.filter((reason) => STALL_LEAVES_NO_PASSAGES[reason]);
+/**
+* Owner-facing prose for a stall reason, and the ONLY place it is worded.
 *
-* Without a marker this state is invisible to every surface at once, which is the failure it exists
-* to prevent: `chunkCount: 0` with `error: null` reads as an image or a pending upload, so health
-* drops it from the denominator, convergence grades it `conformant` (its stale stamp still matches),
-* search does not withhold it because it is not "in flight", and the rescue sweep's own filter
-* passes over it. The file's passages are simply gone and nothing reports it.
+* `vectorizePaused` and `rechunkPaused` are the exact strings those markers used while they lived in
+* `notes`, which is also what the #2016 migration matches on to derive the field for existing rows -
+* do not reword either without updating it. `unchunkedPaused` postdates that migration and was never
+* written to `notes`, so its wording is free to change: nothing matches on it.
+*/
+const CHUNK_STALL_NOTICES = {
+	vectorizePaused: "Indexing paused by the data-lake convergence kill switch - reprocess to complete.",
+	rechunkPaused: "Re-chunking paused by the data-lake convergence kill switch - its passages were removed and are rebuilt when convergence resumes.",
+	unchunkedPaused: "Chunking paused by the data-lake convergence kill switch - this file has no passages yet and they are built when convergence resumes."
+};
+CHUNK_STALL_NOTICES.vectorizePaused;
+CHUNK_STALL_NOTICES.rechunkPaused;
+/**
+* TRANSITIONAL, and the ONE stall predicate every RETRIEVAL path must use until #2016's migration
+* has run in every environment. Reads the new field, then falls back to the legacy prose that the
+* pre-migration rows still carry in `notes`.
+*
+* It exists for the FORWARD window only: `migratorInvocation` is a `dependsOn` of the web stack
+* only (infra/web.ts); the queue stack has none, so the executor can serve forced retrieval and
+* `knowledge_base_search` while rows still carry the marker in `notes` and no `chunkStallReason`. A
+* row stalled by the chunk arm then reads as a plain unindexed file: `isRetrievalExcluded` drops it
+* upstream of the withhold on a vectorizedOnly lake, and `partitionByIndexAvailability` calls it
+* servable everywhere else. The turn answers around a passage-less file and reports FULL coverage -
+* the silent degradation this whole path exists to prevent.
+*
+* A code ROLLBACK is the mirror image and this arm CANNOT cover it: the rows are already migrated
+* (`chunkStallReason` set, `notes` unset) and the code restored is pre-#2016, which does not contain
+* this function. Nothing reverts the data on its own either - `migratorInvocation` only ever runs
+* `up` and `migrate down` is a manual CLI step - so `migrate down` is a REQUIRED step of any
+* rollback past #2016, not an optional tidy-up. What this arm does buy is that `down()` is safe to
+* run FIRST: whichever stack is still new keeps honoring the prose it restores, so a staggered
+* rollback has no window where a restored marker is invisible. `down()` is a PARTIAL restore
+* though - it skips a row whose owner typed a note after `up()`, and that row grades as unstalled
+* on both stacks once the field is dropped. See its own comment.
+*
+* Deliberately NOT used by the grading/health/UI readers: they are gated behind the web stack, and
+* a legacy row there renders the notice line AND the identical text as the owner's note.
 *
-* Same cross-layer reason as the constant above for living here: the queue handler writes it and
-* b4m-core's evaluators read it, and b4m-core cannot import from apps/client.
+* Mirrored in Mongo by `buildFabFileSearchQuery`'s `vectorizedOnly` exemption. Delete the legacy arm
+* from both together, one release after the migration has landed everywhere.
+*
+* Pinned to the two reasons the migration backfilled rather than every notice: `unchunkedPaused`
+* postdates it, so no row carries its prose, and including it would read an owner who happens to type
+* that sentence into `notes` as stalled.
 */
-const CONVERGENCE_PAUSED_CHUNK_NOTE = "Re-chunking paused by the data-lake convergence kill switch - its passages were removed and are rebuilt when convergence resumes.";
+const LEGACY_CHUNK_STALL_NOTES = [CHUNK_STALL_NOTICES.vectorizePaused, CHUNK_STALL_NOTICES.rechunkPaused];
+function isChunkStalledFile(file) {
+	return isChunkStalled(file.chunkStallReason) || LEGACY_CHUNK_STALL_NOTES.includes(file.notes ?? "");
+}
 /**
 * `FabFile.chunkRebuildRequestedAt`: stamped by `resetChunkStateByIds` in the SAME write that
 * clears a file's chunk rollups, so "this file's passages are being rebuilt" can never be lost the
 * way the pair of steps that creates the state can be. The reset and the queue send are two
 * operations - kill the producer between them, or lose the consumer's marker write, and the file
-* sits at `chunkCount: 0` with `error: null` and `notes: ''`, a shape indistinguishable from an
+* sits at `chunkCount: 0` with `error: null` and no stall reason, a shape indistinguishable from an
 * image or a still-uploading row. It then drops out of lake health's denominator, out of the
 * convergence plan and out of the retrieval withhold at the same moment: every rollup says its
 * passages are gone, and nothing reports it.
 *
-* Deliberately NOT `CONVERGENCE_PAUSED_CHUNK_NOTE` pre-written by the producer, which is the obvious
+* Deliberately NOT the `rechunkPaused` stall reason pre-written by the producer, which is the obvious
 * fix and the wrong one: that marker means "halted, needs an administrator", so a file awaiting an
 * ORDINARY rebuild would read to every reader as permanently paused for the whole rebuild - search
 * would tell readers it does not return on its own, health would hard-fail P3, and "Rebuild
@@ -5861,9 +6576,9 @@ const CONVERGENCE_PAUSED_CHUNK_NOTE = "Re-chunking paused by the data-lake conve
 * upgrade therefore degrades to mislabelled-but-visible rather than invisible, which is the trade
 * this field exists to make - invisibility is the real harm, labelling is secondary.
 *
-* A dedicated field rather than a third `notes` string on purpose: `notes` already carries two
-* unrelated facts (the user's own note / NO_EXTRACTABLE_TEXT, and the kill-switch markers), so every
-* writer of it clobbers the others.
+* A dedicated field on purpose, and the precedent #2016 followed for the other two machine-written
+* facts: while they all shared `notes` every writer of that field clobbered the others, including
+* the user's own note.
 *
 * Cleared by `commitFabFileChunks` (the rebuild landed) and by the chunk handler's pause write (the
 * rebuild was halted instead). A file carrying `error` is settled regardless - see
@@ -5872,20 +6587,6 @@ const CONVERGENCE_PAUSED_CHUNK_NOTE = "Re-chunking paused by the data-lake conve
 function isChunkRebuildPending(requestedAt) {
 	return requestedAt !== null && requestedAt !== void 0 && requestedAt !== "";
 }
-/**
-* Whether a file's `notes` marks it as stalled by the convergence kill switch, by either arm.
-* THE predicate every reader uses, so adding a third stall marker reaches health, convergence and
-* retrieval without three separate string comparisons drifting apart.
-*/
-function isConvergencePausedNote(notes) {
-	return CONVERGENCE_PAUSED_NOTES.includes(notes);
-}
-/**
-* Datastore mirror of `isConvergencePausedNote`, for a Mongo `notes: { $in: [...] }`. Exported so a
-* query and the in-memory predicate cannot drift: adding a third stall marker to this array reaches
-* both. Declared after the two constants it names so the function above can close over it.
-*/
-const CONVERGENCE_PAUSED_NOTES = [CONVERGENCE_PAUSED_NOTE, CONVERGENCE_PAUSED_CHUNK_NOTE];
 /** Ceiling so "adjustable" cannot mean "unbounded" in either direction. */
 const LAKE_ACCESS_AUDIT_RETENTION_MAX_DAYS = 2555;
 /**
@@ -5917,14 +6618,13 @@ const LAKE_CONFIG_AUDIT_RETENTION_DEFAULT_DAYS = 1095;
 /** Ceiling so "adjustable" cannot mean "unbounded" in either direction. */
 const LAKE_CONFIG_AUDIT_RETENTION_MAX_DAYS = 3650;
 /**
-* Forced-retrieval budget defaults, shared between the admin-settings schema in this package and
-* `ChatCompletionFeatures.ts` (which cannot import from `common`'s settings schema without a
-* dependency cycle, so the constant lives here instead).
+* Forced-retrieval budget and relevance defaults, shared between the admin-settings schema in this
+* package and `ChatCompletionFeatures.ts` (which cannot import from `common`'s settings schema
+* without a dependency cycle, so the constants live here instead).
 *
-* Only `FORCED_RETRIEVAL_CHAR_BUDGET_DEFAULT` is a lever (see the `forcedRetrievalCharBudget`
-* setting) - the char budget is the measured binding constraint on how much of a corpus reaches
-* the model on every Data-Lake-mode turn. The relevance floor is exported alongside it so the two
-* stay next to each other, not because it is tunable today.
+* All three are levers. The char budget is the measured binding constraint on how much of a corpus
+* reaches the model on every Data-Lake-mode turn; the two floors decide which passages are eligible
+* to spend it (see `forcedRetrievalRelativeFloorPct` and `forcedRetrievalMinSimilarityPct`).
 */
 /** Total characters of retrieved chunk text injected into a forced-retrieval prompt. */
 const FORCED_RETRIEVAL_CHAR_BUDGET_DEFAULT = 12e3;
@@ -5958,12 +6658,23 @@ let OllamaEmbeddingModel = /* @__PURE__ */ function(OllamaEmbeddingModel) {
 	return OllamaEmbeddingModel;
 }({});
 /**
-* The default embedding model for the current deployment. On self-host with a local Ollama
-* server and no cloud embedding key, this is a local embedder, so RAG / knowledge search work
-* out of the box with no AWS/OpenAI/Voyage credential; otherwise it is the cloud default. Read
-* by the `defaultEmbeddingModel` admin-setting default and by the query-embedding fallback, so
-* an operator who never opens admin settings still gets a working, keyless embedder instead of
-* an unconfigured cloud model that fails with an opaque "security token" error.
+* The default embedding model this deployment advertises - the `defaultEmbeddingModel` admin-setting
+* default and the query-embedding fallback, so an operator who never opens admin settings still gets
+* a sensible model rather than an unconfigured one.
+*
+* Deliberately answers from the ENVIRONMENT only, and deliberately does NOT try to answer "can this
+* deployment actually reach that model". It cannot: on a hosted stage an SST secret arrives as a
+* linked Resource, never as process.env (see apps/client/server/modelDiscovery/adapters.ts), so an
+* absent OPENAI_API_KEY here means "unknown", not "no key" - it is absent on production too. This
+* function is also bundled into the browser via settingsMap, where every env read is undefined, so
+* any answer it gives must be one that is safe as a stage-neutral constant.
+*
+* Reachability is therefore decided where the resolved credentials are actually in hand, by
+* `resolveEmbeddingWithKeylessFallback` (fab-pipeline) - that is what lets a keyless cloud stage
+* embed on Bedrock without changing what any other stage advertises.
+*
+* The one arm that IS env-decidable: a self-host running Ollama has its base URL in real process.env
+* on both server and (absent) client, and no cloud credential can arrive by any other route.
 */
 function defaultEmbeddingModelForEnv() {
 	const selfHost = process.env.B4M_SELF_HOST === "true";
@@ -5972,6 +6683,45 @@ function defaultEmbeddingModelForEnv() {
 	if (selfHost && hasOllama && !hasCloudEmbeddingKey) return "qwen3-embedding:0.6b";
 	return "text-embedding-ada-002";
 }
+/**
+* True when this deployment can embed with no provider API key at all: a cloud stage reaches
+* Bedrock through its task/execution role's AWS credentials.
+*
+* Requires POSITIVE evidence of an execution role rather than merely "not self-host". A plain
+* `next dev` session and a CI job both leave B4M_SELF_HOST unset while holding no AWS credentials
+* at all, so an absence test would send them to the Bedrock SDK for an opaque `CredentialsProvider
+* Error` in place of the actionable OPENAI_KEY_MISSING_MESSAGE naming the key to set - the same
+* actionable-to-opaque trade this fallback exists to avoid, just in a different keyless place.
+*
+* BOTH runtimes must be covered, and they carry different markers. The Lambdas (vectorize
+* subscriber, the crons, the Next API routes) get AWS_LAMBDA_FUNCTION_NAME; ChatCompletion is a
+* Fargate service (infra/chatCompletion.ts) and gets the ECS task-role URI instead. Since
+* knowledgeBaseSearch runs inside that container, keying on the Lambda marker alone would leave
+* chat knowledge-base search failing on exactly the keyless stages this fallback is for.
+*
+* SST_RESOURCE_App is the third arm and the one this repo can prove: SST sets it on anything it
+* links, Lambda and Service alike (infra/chatCompletion.ts:129 and infra/agentExecutor.ts:54 both
+* note that linking alone exposes SST_RESOURCE_*). It covers the Fargate task whether or not the
+* ECS credential URI is present, and it is absent from a plain `next dev` and from CI, which is
+* the case that matters. `sst dev` does set it - correctly, since that session runs against real
+* AWS credentials.
+*
+* Self-host is excluded outright because it has no such role - its keyless path is the local
+* Ollama embedder (`isLocalEmbedderAvailable` in toolAvailability.ts), not Bedrock.
+*
+* Answers "is Bedrock reachable here", NOT "should we use it" - a keyed stage is keyless-capable
+* too, so this must only ever be asked ALONGSIDE a resolved credential table that came back empty.
+* `resolveEmbeddingWithKeylessFallback` is where the two questions are paired for callers free to
+* choose the model, and is what such a caller should use instead of asking this directly. The
+* direct callers are the ones that additionally need the answer BEFORE resolving, to decide
+* policy: toolAvailability reports whether embedding-backed tools are usable at all, and
+* data-lakes/semantic-search decides whether a substitution is permitted for this request before
+* it knows whether one is needed. Both still pair it with the table.
+*/
+function hasKeylessCloudEmbedder() {
+	if (process.env.B4M_SELF_HOST === "true") return false;
+	return !!(process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI || process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI || process.env.SST_RESOURCE_App);
+}
 z$1.union([
 	z$1.enum(OpenAIEmbeddingModel),
 	z$1.enum(VoyageAIEmbeddingModel),
@@ -5979,6 +6729,18 @@ z$1.union([
 	z$1.enum(OllamaEmbeddingModel)
 ]);
 /**
+* The measured per-space floors, rendered for an admin-facing description (e.g. "75 for
+* text-embedding-ada-002, 35 for text-embedding-3-small").
+*
+* Rendered rather than written out in prose because these numbers are expected to move - 35 is
+* provisional until it is re-derived against a production lake - and a description that restates
+* the table is a wrong number shown to operators the moment it drifts, with nothing failing.
+*/
+const forcedRetrievalFloorsBySpaceSummary = Object.entries({
+	["text-embedding-ada-002"]: 75,
+	["text-embedding-3-small"]: 35
+}).map(([space, pct]) => `${pct} for ${space}`).join(", ");
+/**
 * Default text for the artifact-emission system prompt. Single source of truth used BOTH as the
 * `ArtifactEmissionPrompt` admin setting's default AND as the runtime fallback in
 * ChatCompletionProcess - so an unset/empty/cleared DB value reverts to this and never bricks
@@ -6082,6 +6844,76 @@ const HELP_CENTER_PROMPT = `HELP CENTER: Bike4Mind has a built-in Help Center th
 */
 const ABSTENTION_PROMPT = `When a request is underspecified or your sources do not cover it, say so and name what is missing. "I do not have enough to answer that" is a correct, high-value answer. Never invent facts about the user, their business, or their data, and never state a specific customer, competitor, deal, or figure as fact - or cite a source for it - unless your sources support it, even when the question assumes it.`;
 /**
+* Default text for the web-search freshness nudge, and the `WebSearchFreshnessPrompt` admin
+* setting's default.
+*
+* Unlike ABSTENTION_PROMPT / ARTIFACT_EMISSION_PROMPT / HELP_CENTER_PROMPT, this setting
+* distinguishes an absent row from a cleared one. ChatCompletionProcess reads it 2-arg, so an
+* absent row still falls back to this constant as the setting's registered default, but a cleared
+* '' is returned verbatim and drops the section rather than reverting. The siblings are read 3-arg
+* and collapse both cases to the constant. That divergence is deliberate - this section has no
+* companion boolean, so clearing the field is the only off switch it has. Keep the setting's
+* description in sync with that if either changes.
+*
+* Names no tool but `web_search`: the section is gated on web_search being offered, and web_fetch
+* is an independent toggle that may well be off.
+*/
+const WEB_SEARCH_FRESHNESS_PROMPT = `# WEB SEARCH AND FRESHNESS
+
+Your training data has a cutoff. The current date is supplied to you in this conversation's system context - treat it as authoritative, and assume anything time-sensitive may have changed since your training.
+
+Call \`web_search\` BEFORE answering when the answer depends on a fact that changes over time: current prices or rates, product availability or roadmap status, funding, organizational or personnel changes, published benchmarks or performance figures, competitive positioning, or anything the user frames as "current", "latest", "now", or "as of today". When a stale answer would mislead, search instead of answering from memory. When a search surfaces a specific page that matters, or the user names one, read that page directly rather than answering from the snippet.
+
+You do not need to search for stable knowledge (definitions, mathematics, established theory), or for questions answerable purely from this conversation or from documents already retrieved for you.
+
+When you report a time-sensitive fact, state what it is as of - the date of the source you used - and say plainly when you could not verify something and are answering from training data instead. Never present an unverified recollection as a current fact.`;
+/**
+* Default text for the knowledge-base retrieval nudge, and the `KnowledgeBaseRetrievalPrompt`
+* admin setting's default.
+*
+* The gap this closes: the tool prompt has a when-to-use section for the clock, for web search,
+* for MCP and for agent delegation, and none for the user's own corpus. The
+* `search_knowledge_base` description is entirely HOW to search ("Make ONE good search per
+* distinct topic") and never WHEN, so on the optional path the model decides unaided - and over 30
+* days of production it reached for the corpus on 20.1% of the turns it was offered on.
+*
+* Read 2-arg by ChatCompletionProcess, exactly as WEB_SEARCH_FRESHNESS_PROMPT is and unlike the
+* 3-arg siblings: an absent row falls back to this constant as the registered default, but a
+* cleared '' is returned verbatim and drops the section instead of reverting. Deliberate - the
+* section has no companion boolean, so clearing the field is its only off switch, and that off
+* switch is what makes it A/B-able without a deploy. Keep the setting's description in sync.
+*
+* Names no tool but `search_knowledge_base`, for the same reason the web-search section names no
+* `web_fetch`: the companion `retrieve_knowledge_content` is paired in at build time but a session
+* denylist can still strip it (ChatCompletionProcess warns on exactly that case), and instructing
+* the model to call a tool it was not given makes it emit the call as leaked JSON text.
+*
+* The "do not search" paragraph is load-bearing, not padding. A when-to-retrieve nudge without a
+* don't-retrieve clause buys retrieval on turns that need none - the same failure mode global
+* forced retrieval already shows on out-of-corpus questions, reached by a different route. Three of
+* its clauses are load-bearing for a specific co-resident path, not general hedging:
+* - "from an attached document" - a small attached corpus is INLINED rather than deferred to
+*   retrieval (`shouldDeferCorpusToRetrieval`), and forced retrieval deliberately steps aside on
+*   an attached-files turn (`forcedRetrievalAbstention` emits nothing there). Without this clause
+*   the section tells the model to go searching for content already sitting in its context.
+* - "already been searched on this turn" - on a forced turn that found nothing,
+*   `forcedRetrievalNoContextPrompt` instructs the model to say the library does not cover the
+*   question. A nudge to search then invites a second identical query - a billed query embedding,
+*   and a chance to talk itself out of a correct abstention.
+* - the opening scope, "unless its content has been placed in this conversation" - the reason the
+*   first paragraph does not simply claim the documents are invisible, which is false whenever a
+*   corpus was inlined.
+*/
+const KNOWLEDGE_BASE_RETRIEVAL_PROMPT = `# KNOWLEDGE BASE
+
+\`search_knowledge_base\` searches a library of documents the user has made available to you - their own uploads, and any shared or organization library they can reach. You cannot see what a document holds unless its content has been placed in this conversation or you search for it; file names and tags are labels, not content.
+
+Call \`search_knowledge_base\` BEFORE answering when that library would settle the question: anything about their organization, projects, customers, products, processes or people; a term, name, acronym or identifier that is not general public knowledge; a policy, decision, figure or date specific to them; or a question that assumes context this conversation never gave you. If you are about to answer in general terms a question the user means specifically, search first. A general-knowledge answer that sounds right is the failure this library exists to prevent.
+
+Do not search when the answer is already in front of you or out of scope: general knowledge (definitions, mathematics, established theory, public facts); anything answerable from this conversation, from an attached document, or from content already retrieved for you this turn; or a request to transform, summarize or reformat text the user has just supplied. If the library has already been searched on this turn, do not search it again for the same question - a repeat spends a round trip to return the same passages.
+
+When a search does not turn up what was asked for, say so plainly rather than filling the gap from training data, and never imply an answer came from the user's documents when it did not.`;
+/**
 * Default text for the formatting system message. Runtime fallback used by
 * `includeHardcodedSystemMessage` (b4m-core/utils/src/llm/utils.ts) when the `FormatPromptTemplate`
 * admin setting is blank; that setting's own default is intentionally '' - keep this the sole home.
@@ -6101,6 +6933,7 @@ z$1.enum([
 	"geminiDemoKey",
 	"xaiApiKey",
 	"moonshotApiKey",
+	"deepseekApiKey",
 	"voyageApiKey",
 	"FirecrawlApiKey",
 	"FirecrawlApiUrl",
@@ -6114,6 +6947,8 @@ z$1.enum([
 	"ArtifactEmissionPrompt",
 	"HelpCenterPrompt",
 	"AbstentionPrompt",
+	"WebSearchFreshnessPrompt",
+	"KnowledgeBaseRetrievalPrompt",
 	"UseFormatPrompt",
 	"EnableQuestMaster",
 	"EnableQuestMasterDefault",
@@ -6132,11 +6967,11 @@ z$1.enum([
 	"EnableLattice",
 	"EnableLatticeDefault",
 	"EnableDataLakes",
-	"EnableDataLakesDefault",
 	"EnableDataLakeSlackAdd",
 	"EnableDataLakeGroundingMode",
 	"EnableLakeMemory",
 	"EnableDataLakeVectorSearch",
+	"EnableRetrievalSupersessionCollapse",
 	"PauseLakeConvergence",
 	"LakeConvergenceBulkChangeSharePct",
 	"EnforceLakeReadGrants",
@@ -6233,16 +7068,21 @@ z$1.enum([
 	"defaultEmbeddingModel",
 	"dataLakeSearchMaxFiles",
 	"dataLakeSearchMaxChunks",
+	"dataLakeSearchMaxChunksPerFile",
 	"forcedRetrievalCharBudget",
+	"lakeMemoryRecallK",
 	"kbSearchDefaultResults",
 	"kbSearchResultTokenBudget",
 	"kbSearchMinRelevancePct",
+	"forcedRetrievalRelativeFloorPct",
+	"forcedRetrievalMinSimilarityPct",
 	"dataLakeEmbeddingSpendEnabled",
 	"dataLakeEmbeddingBudgetPerRunUsd",
 	"dataLakeEmbeddingBudgetPerLakeUsd",
 	"dataLakeEmbeddingBudgetPerPeriodUsd",
 	"dataLakeEmbeddingBudgetPeriodHours",
 	"dataLakeEmbeddingMaxCallsPerMinute",
+	"dataLakeEmbeddingMaxTokensPerMinute",
 	"dataLakeVectorizeChunkBatchSize",
 	"dataLakeEmbeddingTierMultiplierIndividual",
 	"dataLakeEmbeddingTierMultiplierOrganization",
@@ -6291,7 +7131,6 @@ z$1.enum([
 	"EnableBmPiDefault",
 	"EnableBmPiJira",
 	"EnableOptiHashi",
-	"EnableOptiHashiDefault",
 	"EnableComputeSubmission",
 	"EnableFamilyCompute",
 	"EnableHybridCompute",
@@ -6319,6 +7158,7 @@ z$1.enum([
 	"modelDiscoveryAllowEgress",
 	"modelDiscoveryPriceBandPct",
 	"modelDiscoveryAutoRemap",
+	"modelDiscoveryProbeNewModels",
 	"prReportRepo",
 	"prReportIdentityMap",
 	"prReportWebhookUrl",
@@ -6361,10 +7201,12 @@ const OrchestrationDefaultsSchema = z$1.object({
 		"mermaid_chart"
 	]),
 	/**
-	* Tool names explicitly forbidden. Enforced as a final subtraction in
-	* `pickEffectiveEnabledTools` - wins even over payload-pinned tools - so this
-	* is the defense-in-depth backstop for the case where an admin broadens
-	* `allowedTools` without realizing a parallel denylist is also needed.
+	* Tool names explicitly forbidden. Enforced in two places: as a final subtraction in
+	* `pickEffectiveEnabledTools` (wins even over payload-pinned tools), and - for the two
+	* delegation tools, which are injected as objects and never registered by name - at the
+	* dependency gate in agentExecutor (`delegationOffer` withholds `agentStore` /
+	* `dagDispatcher`). The name subtraction alone cannot reach those two; see
+	* agentExecutor.sessionToolPolicy.
 	*
 	* Seeded with every tool that mutates user data (the spec's
 	* "anything tagged `mutates_user_data`"): destructive/overwriting filesystem
@@ -6442,8 +7284,30 @@ const DATA_LAKE_SEARCH_MAX_CHUNKS_DEFAULT = 1e5;
 const DATA_LAKE_EMBEDDING_BUDGET_PER_LAKE_USD_MAX = 1e4;
 const DATA_LAKE_EMBEDDING_BUDGET_PER_PERIOD_USD_MAX = 5e3;
 const DATA_LAKE_EMBEDDING_MAX_CALLS_PER_MINUTE_MAX = 1e4;
+/**
+* The TOKEN half of the throughput cap, and the one that maps to what providers actually meter.
+* A call cap alone does not bound tokens: one call carries up to
+* DATA_LAKE_VECTORIZE_CHUNK_BATCH_SIZE_DEFAULT passages of DEFAULT_PASSAGE_TOKEN_TARGET tokens, so
+* 120 calls/min permits ~3.1M tokens/min - several times the smallest paid embeddings tier. The two
+* levers are complementary: calls/min bounds RPM, this bounds TPM, and a call must fit both.
+*
+* The default is deliberately LOW - it has to be safe on the smallest tier any deployment might
+* be on, including self-hosts nobody here can see. It is not a claim about what any particular
+* account can do, and reading it as one is the mistake to avoid: a provider tier is a property of
+* the provider organization, so it cannot be derived from this codebase at all.
+*
+* The real number is measurable per deployment: Admin -> Settings -> AI -> Data Lake Cost
+* Governance reads the configured provider's live ceiling (GET /api/admin/embedding-limits) and
+* shows it beside this lever, so an operator sets this from their own measured quota rather than
+* from a guess baked in here. Leave headroom below the measured ceiling for QUERY-side embedding,
+* which is exempt from this gate (see enforceEmbeddingSpendGate) and shares the same per-model
+* pool - a retrieval query must not queue behind a backfill.
+*/
+const DATA_LAKE_EMBEDDING_MAX_TOKENS_PER_MINUTE_DEFAULT = 6e5;
+const DATA_LAKE_EMBEDDING_MAX_TOKENS_PER_MINUTE_MAX = 5e7;
 function makeNumberSetting(config) {
 	let numberSchema = z$1.coerce.number();
+	if (config.int) numberSchema = numberSchema.int();
 	if (config.min !== void 0) numberSchema = numberSchema.min(config.min);
 	if (config.max !== void 0) numberSchema = numberSchema.max(config.max);
 	return {
@@ -7010,6 +7874,14 @@ const API_SERVICE_GROUPS = {
 			{
 				key: "AbstentionPrompt",
 				order: 11
+			},
+			{
+				key: "WebSearchFreshnessPrompt",
+				order: 12
+			},
+			{
+				key: "KnowledgeBaseRetrievalPrompt",
+				order: 13
 			}
 		]
 	},
@@ -7046,6 +7918,22 @@ const API_SERVICE_GROUPS = {
 			{
 				key: "kbSearchMinRelevancePct",
 				order: 7
+			},
+			{
+				key: "lakeMemoryRecallK",
+				order: 8
+			},
+			{
+				key: "forcedRetrievalRelativeFloorPct",
+				order: 9
+			},
+			{
+				key: "forcedRetrievalMinSimilarityPct",
+				order: 10
+			},
+			{
+				key: "dataLakeSearchMaxChunksPerFile",
+				order: 11
 			}
 		]
 	},
@@ -7080,16 +7968,20 @@ const API_SERVICE_GROUPS = {
 				order: 6
 			},
 			{
-				key: "dataLakeVectorizeChunkBatchSize",
+				key: "dataLakeEmbeddingMaxTokensPerMinute",
 				order: 7
 			},
 			{
-				key: "dataLakeEmbeddingTierMultiplierIndividual",
+				key: "dataLakeVectorizeChunkBatchSize",
 				order: 8
 			},
 			{
-				key: "dataLakeEmbeddingTierMultiplierOrganization",
+				key: "dataLakeEmbeddingTierMultiplierIndividual",
 				order: 9
+			},
+			{
+				key: "dataLakeEmbeddingTierMultiplierOrganization",
+				order: 10
 			}
 		]
 	},
@@ -7149,6 +8041,16 @@ const API_SERVICE_GROUPS = {
 			order: 1
 		}]
 	},
+	DEEPSEEK: {
+		id: "deepseekAPIService",
+		name: "DeepSeek Service",
+		description: "DeepSeek API integration settings",
+		icon: "AutoAwesome",
+		settings: [{
+			key: "deepseekApiKey",
+			order: 1
+		}]
+	},
 	ANTHROPIC: {
 		id: "anthropicAPIService",
 		name: "Anthropic Service",
@@ -7486,10 +8388,6 @@ const API_SERVICE_GROUPS = {
 				key: "EnableOptiHashi",
 				order: 80
 			},
-			{
-				key: "EnableOptiHashiDefault",
-				order: 81
-			},
 			{
 				key: "EnableComputeSubmission",
 				order: 82
@@ -7852,6 +8750,10 @@ const API_SERVICE_GROUPS = {
 			{
 				key: "modelDiscoveryAutoRemap",
 				order: 6
+			},
+			{
+				key: "modelDiscoveryProbeNewModels",
+				order: 7
 			}
 		]
 	},
@@ -7937,6 +8839,16 @@ const settingsMap = {
 		group: API_SERVICE_GROUPS.MOONSHOT.id,
 		order: 1
 	}),
+	deepseekApiKey: makeStringSetting({
+		key: "deepseekApiKey",
+		name: "DeepSeek API Key",
+		defaultValue: "",
+		description: "The global API Key for DeepSeek.",
+		isSensitive: true,
+		category: "AI",
+		group: API_SERVICE_GROUPS.DEEPSEEK.id,
+		order: 1
+	}),
 	voyageApiKey: makeStringSetting({
 		key: "voyageApiKey",
 		name: "Voyage API Key",
@@ -7985,16 +8897,6 @@ const settingsMap = {
 		group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
 		order: 88
 	}),
-	EnableDataLakesDefault: makeBooleanSetting({
-		key: "EnableDataLakesDefault",
-		name: "Data Lakes: On by default for users",
-		defaultValue: false,
-		description: "When enabled, Data Lakes is active for users who have never explicitly toggled it.",
-		category: "Experimental",
-		group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
-		order: 89,
-		dependsOn: "EnableDataLakes"
-	}),
 	EnableDataLakeSlackAdd: makeBooleanSetting({
 		key: "EnableDataLakeSlackAdd",
 		name: "Data Lakes: Slack \"@datalake add\" path",
@@ -8019,7 +8921,7 @@ const settingsMap = {
 		key: "EnableLakeMemory",
 		name: "Data Lakes: Lake memory profile (extraction)",
 		defaultValue: false,
-		description: "Server-side gate for the lake memory producer - LLM extraction of a data lake's documents into a durable memory profile on ingest. Off by default (measurement rollout); the consumer that injects the profile is inert until this is on and a lake has been extracted.",
+		description: "Master gate for lake memory, on all three sides: LLM extraction of a data lake's documents into a durable memory profile, recall of that profile into chats grounded in the lake, and whether the per-lake opt-in is offered at all. Off by default (measurement rollout). Turning it off stops recall immediately and stops new extractions from being queued or picked up, though a run already in flight finishes its slice (bounded by the handler timeout). It is NOT destructive - each lake keeps its own opt-in and its built profile, so flipping this back on resumes where it left off. Erasing a profile is a separate, explicit per-lake action.",
 		category: "Experimental",
 		group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
 		order: 91,
@@ -8035,11 +8937,21 @@ const settingsMap = {
 		order: 92,
 		dependsOn: "EnableDataLakes"
 	}),
+	EnableRetrievalSupersessionCollapse: makeBooleanSetting({
+		key: "EnableRetrievalSupersessionCollapse",
+		name: "Data Lakes: Collapse superseded members before ranking",
+		defaultValue: false,
+		description: "When a lake holds two generations of the same document (a re-upload, a Drive sync, a migration), rank only the newest and report the suppression. Off by default: the weakest identity tier is a bare file name, so two genuinely different documents sharing a name in one lake would collapse to one - turn this on only after checking the reported collapse counts on real lakes. Suppression is recoverable either way; a collapsed member is still reachable by id or name through retrieve_knowledge_content.",
+		category: "Experimental",
+		group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
+		order: 97,
+		dependsOn: "EnableDataLakes"
+	}),
 	PauseLakeConvergence: makeBooleanSetting({
 		key: "PauseLakeConvergence",
 		name: "Data Lakes: Pause background convergence work",
 		defaultValue: false,
-		description: "Kill switch for background data-lake ingestion work (convergence sweeps, rescue re-chunking) - NOT real-time user uploads, which are always honored. Off by default. Turn ON to halt in-flight background chunk/vectorize messages the next time the handler picks them up (a re-check inside the shared handler, so it takes effect on work already queued, not just the next scheduling pass). The platform value pauses every lake at once; a per-lake (or per-org / per-owner) override pauses a subset while the rest keep running. A platform-level flip applies immediately to lake-wide work and within ~5 min to per-lake-scoped work (settings cache).",
+		description: "Kill switch for background data-lake ingestion work (convergence sweeps, rescue re-chunking) - NOT real-time user uploads, which are always honored. Off by default. Turn ON to halt in-flight background chunk/vectorize messages the next time the handler picks them up (a re-check inside the shared handler, so it takes effect on work already queued, not just the next scheduling pass). The platform value pauses every lake at once; a per-lake (or per-org / per-owner) override pauses a subset while the rest keep running - including overriding a platform-wide pause back OFF for one lake. Every producer honors the override, the global chunk rescue sweep included: it resolves each candidate against the lake it belongs to (#2157), so a file in no lake at all follows the platform value, which is correct for it. A platform-level flip applies immediately to lake-wide work and within ~5 min to per-lake-scoped work (settings cache).",
 		category: "Experimental",
 		group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
 		order: 93,
@@ -8069,8 +8981,8 @@ const settingsMap = {
 	EnforceLakeReadGrants: makeBooleanSetting({
 		key: "EnforceLakeReadGrants",
 		name: "Data Lakes: Enforce read-time grant resolution",
-		defaultValue: false,
-		description: "Read-time grant cutover (#1673). OFF by default = report-only: the read gate resolves a persisted READER/org grant into an ephemeral membership view and logs where it WOULD change access ([lakeReadGrantCutover] lines), but the enforced decision stays the legacy owner/org/tag/entitlement/public rule so no one gains or loses access. NOTE: turning this ON is currently a NO-OP guarded by a source-level interlock (READ_GRANT_ENFORCEMENT_READY) - enforcement will not activate until the follow-up code (member-management write path + retrieval arm) lands and flips it, and a premature toggle just logs a warning and stays report-only. This is deliberate so the setting cannot half-enable a half-wired gate. Platform altitude on purpose: a one-time install-wide migration cutover, not a per-lake lever. Tag and entitlement grants always resolve live and are never affected by this flag; only persisted reader/org rows are gated by it.",
+		defaultValue: true,
+		description: "Read-time grant resolution (#1673). ON is the shipped default: a persisted READER or ORG grant is resolved into the read decision, so a principal a lake was shared with can browse it, open it and ground on it. Resolution is purely ADDITIVE (legacy OR grant), so it takes no access away; this arm contains an ORG grant to the granting org, and expired rows never resolve. This is the standing KILL SWITCH for that arm, not a migration phase: turning it OFF returns to report-only, where the gate still resolves grants and logs where they WOULD change access ([lakeReadGrantCutover] lines) but the enforced decision falls back to the legacy owner/org/tag/entitlement/public rule - so those log lines are the diagnostic for a lake someone can no longer reach while the switch is off. Platform altitude on purpose: install-wide, not a per-lake lever. Tag and entitlement grants always resolve live and are never affected by this flag; only persisted reader/org rows are gated by it.",
 		category: "Experimental",
 		group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
 		order: 94,
@@ -8320,6 +9232,7 @@ const settingsMap = {
 	}),
 	DefaultChunkSize: makeNumberSetting({
 		key: "DefaultChunkSize",
+		userReadable: true,
 		name: "Default Chunk Size",
 		defaultValue: 512,
 		min: 64,
@@ -8378,6 +9291,22 @@ const settingsMap = {
 		category: "AI",
 		order: 11
 	}),
+	WebSearchFreshnessPrompt: makeStringSetting({
+		key: "WebSearchFreshnessPrompt",
+		name: "Web Search Freshness Prompt",
+		defaultValue: WEB_SEARCH_FRESHNESS_PROMPT,
+		description: "System prompt telling the model when to reach for web_search rather than answer from training data, and to state the as-of date of any time-sensitive fact. Injected only when the web_search tool is offered for the request - a model instructed to search without a search tool tends to claim it searched. Clearing this field turns the section OFF rather than restoring the built-in default, and it is the only off switch this section has; to get the stock wording back, paste it in. A change is not instantaneous: the settings cache is per-instance, so it applies immediately on the instance that served the change and within ~5 min (one cache TTL) everywhere else. After an upgrade, diff a saved copy against the built-in default: a saved copy pins the wording from whenever it was saved and will not pick up fixes made since.",
+		category: "AI",
+		order: 12
+	}),
+	KnowledgeBaseRetrievalPrompt: makeStringSetting({
+		key: "KnowledgeBaseRetrievalPrompt",
+		name: "Knowledge Base Retrieval Prompt",
+		defaultValue: KNOWLEDGE_BASE_RETRIEVAL_PROMPT,
+		description: "System prompt telling the model when to reach for search_knowledge_base rather than answer from training data, and when NOT to. Injected only when the search_knowledge_base tool is offered for the request - a model instructed to search a corpus it has no tool for tends to claim it searched. Clearing this field turns the section OFF rather than restoring the built-in default, and it is the only off switch this section has; to get the stock wording back, paste it in. A change is not instantaneous: the settings cache is per-instance, so it applies immediately on the instance that served the change and within ~5 min (one cache TTL) everywhere else. After an upgrade, diff a saved copy against the built-in default: a saved copy pins the wording from whenever it was saved and will not pick up fixes made since.",
+		category: "AI",
+		order: 13
+	}),
 	UseFormatPrompt: makeBooleanSetting({
 		key: "UseFormatPrompt",
 		name: "Use Format Prompt",
@@ -8396,6 +9325,7 @@ const settingsMap = {
 	}),
 	pricePerCredit: makeNumberSetting({
 		key: "pricePerCredit",
+		userReadable: true,
 		name: "Price Per Credit",
 		defaultValue: 50,
 		description: "The price per credit for purchasing credits.",
@@ -8473,7 +9403,8 @@ const settingsMap = {
 		name: "Referal Credits Amount",
 		defaultValue: 1e4,
 		description: "Credits to give to the referred user.",
-		category: "Referrals"
+		category: "Referrals",
+		userReadable: true
 	}),
 	EnableReferralToEmail: makeBooleanSetting({
 		key: "EnableReferralToEmail",
@@ -8662,8 +9593,10 @@ const settingsMap = {
 	}),
 	MaxFileSize: makeNumberSetting({
 		key: "MaxFileSize",
+		userReadable: true,
 		name: "Max File Size",
 		defaultValue: 30,
+		min: 1,
 		description: "The maximum file size allowed for uploads in MB.",
 		category: "Knowledge",
 		group: API_SERVICE_GROUPS.KNOWLEDGE.id,
@@ -8770,6 +9703,7 @@ const settingsMap = {
 	}),
 	enforceCredits: makeBooleanSetting({
 		key: "enforceCredits",
+		userReadable: true,
 		name: "Enforce Credits",
 		defaultValue: process.env.B4M_SELF_HOST === "true" ? false : true,
 		description: "Whether to enforce credits for users",
@@ -8786,6 +9720,7 @@ const settingsMap = {
 	}),
 	enableTeamPlan: makeBooleanSetting({
 		key: "enableTeamPlan",
+		userReadable: true,
 		name: "Enable Team Plan",
 		defaultValue: false,
 		description: "Whether to enable team plans",
@@ -8891,7 +9826,8 @@ const settingsMap = {
 		description: "The global system prompt files to be used for AI model configuration.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.OPENAI.id,
-		order: 8
+		order: 8,
+		userReadable: true
 	}),
 	OpenWeatherKey: makeStringSetting({
 		key: "OpenWeatherKey",
@@ -9045,6 +9981,7 @@ const settingsMap = {
 	}),
 	MaxContentLength: makeNumberSetting({
 		key: "MaxContentLength",
+		userReadable: true,
 		name: "Max Content Length",
 		defaultValue: 5e4,
 		description: "The maximum character length for file content displayed in workbench (truncated if larger).",
@@ -9210,9 +10147,10 @@ const settingsMap = {
 	}),
 	defaultEmbeddingModel: makeStringSetting({
 		key: "defaultEmbeddingModel",
+		userReadable: true,
 		name: "Default Embedding Model",
 		defaultValue: defaultEmbeddingModelForEnv(),
-		description: "The default embedding model to use",
+		description: "The default embedding model to use. Changing it changes the SCALE of every similarity score in the system, so relevance floors do not carry across: a floor tuned for one model can sit above the entire range of another and reject everything. The server handles this for you on the floors it ships, applying the value measured for whichever model your documents are actually embedded with - but if you have set Forced Retrieval Absolute Floor by hand, re-measure it after changing this. Existing documents keep their old vectors and are only comparable to a query embedded the same way, so a change here needs a re-embed to take full effect; until then each set of documents is searched with the model it was indexed under.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.EMBEDDING.id,
 		options: [
@@ -9231,11 +10169,7 @@ const settingsMap = {
 		category: "AI",
 		group: API_SERVICE_GROUPS.EMBEDDING.id,
 		order: 2,
-		scope: { settableAt: [
-			"organization",
-			"owner",
-			"lake"
-		] }
+		scope: { settableAt: ["organization", "owner"] }
 	}),
 	dataLakeSearchMaxChunks: makeNumberSetting({
 		key: "dataLakeSearchMaxChunks",
@@ -9246,11 +10180,18 @@ const settingsMap = {
 		category: "AI",
 		group: API_SERVICE_GROUPS.EMBEDDING.id,
 		order: 3,
-		scope: { settableAt: [
-			"organization",
-			"owner",
-			"lake"
-		] }
+		scope: { settableAt: ["organization", "owner"] }
+	}),
+	dataLakeSearchMaxChunksPerFile: makeNumberSetting({
+		key: "dataLakeSearchMaxChunksPerFile",
+		name: "Data Lake Search Max Chunks Per Document",
+		defaultValue: 0,
+		min: 0,
+		description: "Most chunks from any ONE source document a data-lake semantic search may return in its top-K. A diversity guard for CONTESTED slots: where several documents answer the question, it stops the best-scoring one from taking slots the others could have filled. It is NOT a fix for severe crowding - the cap redistributes only among the candidates retrieval already returned, so a document that supplies enough of the top-scoring chunks to fill that pool on its own is one the cap cannot change at all. On a corpus of book-length documents, expect enabling this to change little beyond widening the vector-search request. 0 (default) disables the cap, byte-identical to behavior before this setting existed. The cap never SHRINKS a result set - once the spread-out picks are in, any slots still open are backfilled with the highest-scoring chunks the cap held back, so a lake whose only match is one document still returns a full top-K. A value at or above the result count is also a no-op, since nothing can ever be held back. Below it, each retrieval stream's candidate pool is widened to a fixed multiple of the result count so the cap has a spread to choose from. The scanned corpus itself does not grow (that is bounded separately), but the vector-search backends are asked for that many more matches, and a larger in-memory ranking pool costs some CPU. 2-3 is the useful range; 1 serves one passage per document, which suits a corpus of many short documents and starves a question whose answer spans one long one. The chat knowledge-base path ranks more passages than it serves, so it applies the cap a second time at the count it actually serves - otherwise the spread-out picks, which are by definition the lowest-scoring ones admitted, would land in the passages that path discards.",
+		category: "AI",
+		group: API_SERVICE_GROUPS.EMBEDDING.id,
+		order: 11,
+		scope: { settableAt: ["organization", "owner"] }
 	}),
 	forcedRetrievalCharBudget: makeNumberSetting({
 		key: "forcedRetrievalCharBudget",
@@ -9258,10 +10199,11 @@ const settingsMap = {
 		defaultValue: FORCED_RETRIEVAL_CHAR_BUDGET_DEFAULT,
 		min: 1e3,
 		max: 1e5,
-		description: "Total characters of retrieved chunk text injected into a Data-Lake-mode turn. Measured saturating on every turn against a 47-document lake, so this is the binding constraint on how much of a corpus reaches the model - not the relevance floor. Raising it admits more passages at the cost of prompt tokens and latency on every Data-Lake turn; it is NOT automatically better, since more context can dilute ranking. Platform-only for now: this read does not go through the scoped-settings resolver, so a `settableAt` block here would be inert metadata at best and could arm the resolver's fail-loud owner check at worst.",
+		description: "Total characters of retrieved chunk text injected into a Data-Lake-mode turn. Measured saturating on every turn against a 47-document lake, so this is the binding constraint on how much of a corpus reaches the model - not the relevance floor. Raising it admits more passages at the cost of prompt tokens and latency on every Data-Lake turn; it is NOT automatically better, since more context can dilute ranking. Overridable per organization and per owner, the same altitude as the two relevance floors resolved alongside it on the same turn.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.EMBEDDING.id,
-		order: 4
+		order: 4,
+		scope: { settableAt: ["organization", "owner"] }
 	}),
 	kbSearchDefaultResults: makeNumberSetting({
 		key: "kbSearchDefaultResults",
@@ -9269,7 +10211,7 @@ const settingsMap = {
 		defaultValue: 5,
 		min: 1,
 		max: 10,
-		description: "Passages the search_knowledge_base tool returns when a model call omits max_results, which is most calls. This is the exact bound while kbSearchResultTokenBudget is unset (0). Once a token budget is set, it takes over as the primary bound for search results (this setting's own value is then unused there, though it still governs the keyword-search fallback, and the count served if token pricing itself fails). Does NOT raise the tool's hard ceiling of 10 passages per call - a model that reads max_results up to 10 from its own tool schema won't ask for more than that regardless of this setting.",
+		description: "Passages the search_knowledge_base tool returns when a model call omits max_results, which is most calls. This is the exact bound while kbSearchResultTokenBudget is unset (0). Once a token budget is set, it takes over as the primary bound for search results (this setting's own value is then unused there, though it still governs the keyword-search fallback, and the count served if token pricing itself fails). Does NOT raise the tool's hard ceiling of 10 passages per call - a model that reads max_results up to 10 from its own tool schema won't ask for more than that regardless of this setting. A change is not instantaneous: the settings cache is per-instance, so it applies immediately on the instance that served the change and within ~5 min (one cache TTL) everywhere else.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.EMBEDDING.id,
 		order: 5,
@@ -9281,7 +10223,7 @@ const settingsMap = {
 		defaultValue: 0,
 		min: 0,
 		max: 2e4,
-		description: "Approximate tokens of served passage TEXT (post-trim, post-clip - what the model actually receives, not the raw stored chunk) the search_knowledge_base tool may return in one call. Counted with a fixed tokenizer as a proxy, not billed against any specific model. Replaces a passage count as the primary bound once set, since it is invariant to chunk size - a lake chunked smaller no longer silently returns less material for the same setting. 0 (default) disables it: search_knowledge_base then serves exactly kbSearchDefaultResults passages, unchanged from before this setting existed. The FIRST matching passage is always returned even if it alone exceeds the budget - a search that found something never returns nothing.",
+		description: "Approximate tokens of served passage TEXT (post-trim, post-clip - what the model actually receives, not the raw stored chunk) the search_knowledge_base tool may return in one call. Counted with a fixed tokenizer as a proxy, not billed against any specific model. Replaces a passage count as the primary bound once set, since it is invariant to chunk size - a lake chunked smaller no longer silently returns less material for the same setting. 0 (default) disables it: search_knowledge_base then serves exactly kbSearchDefaultResults passages, unchanged from before this setting existed. The FIRST matching passage is always returned even if it alone exceeds the budget - a search that found something never returns nothing. A change is not instantaneous: the settings cache is per-instance, so it applies immediately on the instance that served the change and within ~5 min (one cache TTL) everywhere else.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.EMBEDDING.id,
 		order: 6,
@@ -9293,12 +10235,50 @@ const settingsMap = {
 		defaultValue: 0,
 		min: 0,
 		max: 100,
-		description: "Minimum cosine relevance, as a percent, a passage must clear to be returned by search_knowledge_base. 0 (default) matches current behavior (no relevance floor beyond a non-negative cosine score). Raising it lets breadth adapt per query - a narrow question can return fewer, more relevant passages instead of always padding out to the configured count. Cosine similarity is not comparable across embedding models: a floor tuned for one model can filter out an entire alternate model, when a lake mixes embedding models, more aggressively than intended. Start low and raise gradually while watching the tool's own retrieval-skipped notices.",
+		description: "Minimum cosine relevance, as a percent, a passage must clear to be returned by search_knowledge_base. 0 (default) matches current behavior (no relevance floor beyond a non-negative cosine score). Raising it lets breadth adapt per query - a narrow question can return fewer, more relevant passages instead of always padding out to the configured count. Cosine similarity is not comparable across embedding models: a floor tuned for one model can filter out an entire alternate model, when a lake mixes embedding models, more aggressively than intended. Start low and raise gradually while watching the tool's own retrieval-skipped notices. A change is not instantaneous: the settings cache is per-instance, so it applies immediately on the instance that served the change and within ~5 min (one cache TTL) everywhere else.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.EMBEDDING.id,
 		order: 7,
 		scope: { settableAt: ["organization", "owner"] }
 	}),
+	lakeMemoryRecallK: makeNumberSetting({
+		key: "lakeMemoryRecallK",
+		name: "Lake Memory Belief Budget",
+		defaultValue: 24,
+		min: 1,
+		max: 200,
+		int: true,
+		description: "Most beliefs the lake memory hot-card injects on a Data-Lake-mode turn, shared across every lake in scope. Recall still applies its cosine floor and the source-reachability gate first, so raising this does not admit low-quality beliefs - it raises the ceiling on how many QUALIFYING beliefs can actually be used, which was pinned at 8 (inherited from personal-memento recall) on no evidence beyond that inheritance. The sibling lever on the same turn is Forced Retrieval Char Budget, which governs raw chunk text rather than extracted beliefs. Platform-only for now, unlike that sibling: this read goes through plain getSettingsValue, which ignores settableAt, so a scope block here would be silently inert - every override written against it would resolve to nothing. Pointing the read at the scoped resolver is the prerequisite, not extra metadata.",
+		category: "AI",
+		group: API_SERVICE_GROUPS.EMBEDDING.id,
+		order: 8
+	}),
+	forcedRetrievalRelativeFloorPct: makeNumberSetting({
+		key: "forcedRetrievalRelativeFloorPct",
+		name: "Forced Retrieval Relative Floor (%)",
+		defaultValue: 85,
+		min: 0,
+		max: 100,
+		int: true,
+		description: "How close to the best-scoring passage of the SAME turn a chunk must score to be injected on a Data-Lake-mode turn, as a percent of that top score. This is the floor that ranks; the absolute floor below only rejects. Unlike an absolute cosine line, it moves with the turn, so it keeps working when a corpus or an embedding model puts the whole score band somewhere else. Raising it injects fewer, more sharply-ranked passages and leaves char budget unspent; lowering it admits more of the tail. 0 disables the relative floor and leaves the absolute one as the only gate (the pre-#2497 behavior). The default is behavior-preserving rather than tuned: it admits everything the absolute floor admitted on the measured band, so it changes nothing until raised. Tune it AFTER an embedding-model change, never before - a migration shifts the band any value fitted to today would have been chosen against.",
+		category: "AI",
+		group: API_SERVICE_GROUPS.EMBEDDING.id,
+		order: 9,
+		scope: { settableAt: ["organization", "owner"] }
+	}),
+	forcedRetrievalMinSimilarityPct: makeNumberSetting({
+		key: "forcedRetrievalMinSimilarityPct",
+		name: "Forced Retrieval Absolute Floor (%)",
+		defaultValue: 75,
+		min: 1,
+		max: 100,
+		int: true,
+		description: `Absolute minimum cosine similarity, as a percent, a chunk must clear to be injected on a Data-Lake-mode turn. This is a sanity floor for genuinely unrelated content, NOT the ranking gate - the relative floor above does the ranking. LEAVE IT AT 75 UNLESS YOU HAVE MEASURED YOUR OWN CORPUS: a raw cosine means nothing outside the embedding model it was fitted to, so while this reads 75 the server ignores it and applies the floor measured for whichever model your documents are actually embedded with (${forcedRetrievalFloorsBySpaceSummary}, and no absolute floor at all for a model nobody has measured - the relative floor still applies). Set any other value and the server uses exactly that, in every space, which is yours to get right: 75 against text-embedding-3-small sits above that band entirely and returns nothing on every query. Where this floor lands inside your band decides a lot - on one measured corpus 74 / 75 / 76 swung recall 91% / 65% / 40% - and the same 75 that is a cliff on one lake rejects nothing at all on another. Re-measure after changing the embedding model; the sweep tool is packages/scripts/retrieval/forcedFloorSweep.ts.`,
+		category: "AI",
+		group: API_SERVICE_GROUPS.EMBEDDING.id,
+		order: 10,
+		scope: { settableAt: ["organization", "owner"] }
+	}),
 	LakeAccessAuditRetentionDays: makeNumberSetting({
 		key: "LakeAccessAuditRetentionDays",
 		name: "Lake Access Audit Retention (days)",
@@ -9334,6 +10314,7 @@ const settingsMap = {
 	}),
 	dataLakeEmbeddingSpendEnabled: makeBooleanSetting({
 		key: "dataLakeEmbeddingSpendEnabled",
+		userReadable: true,
 		name: "Data Lake Embedding Spend Enabled",
 		defaultValue: true,
 		description: "Master switch for data-lake embedding spend (ingestion, reprocessing, convergence). Off halts all provider embedding calls on those paths; cached embeddings still apply.",
@@ -9343,6 +10324,7 @@ const settingsMap = {
 	}),
 	dataLakeEmbeddingBudgetPerRunUsd: makeNumberSetting({
 		key: "dataLakeEmbeddingBudgetPerRunUsd",
+		userReadable: true,
 		name: "Embedding Budget Per Run (USD)",
 		defaultValue: 5,
 		min: 0,
@@ -9396,6 +10378,17 @@ const settingsMap = {
 		group: API_SERVICE_GROUPS.DATA_LAKE_COST.id,
 		order: 6
 	}),
+	dataLakeEmbeddingMaxTokensPerMinute: makeNumberSetting({
+		key: "dataLakeEmbeddingMaxTokensPerMinute",
+		name: "Embedding Max Tokens Per Minute",
+		defaultValue: DATA_LAKE_EMBEDDING_MAX_TOKENS_PER_MINUTE_DEFAULT,
+		min: 0,
+		max: DATA_LAKE_EMBEDDING_MAX_TOKENS_PER_MINUTE_MAX,
+		description: "Most provider embedding TOKENS per minute across all data-lake work, which is the quantity providers actually meter. The calls-per-minute lever alone does not bound this: one call carries a whole batch of passages. Set it from your provider dashboard TPM, leaving headroom for query-side embedding (exempt, so a search never queues behind a backfill). 0 stops all calls.",
+		category: "AI",
+		group: API_SERVICE_GROUPS.DATA_LAKE_COST.id,
+		order: 7
+	}),
 	dataLakeVectorizeChunkBatchSize: makeNumberSetting({
 		key: "dataLakeVectorizeChunkBatchSize",
 		name: "Vectorize Chunk Batch Size",
@@ -9405,7 +10398,7 @@ const settingsMap = {
 		description: "How many chunks the chunk handler packs into one vectorize-queue message. Smaller batches smooth the fan-out; not a spend value, so min 1.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.DATA_LAKE_COST.id,
-		order: 7
+		order: 8
 	}),
 	dataLakeEmbeddingTierMultiplierIndividual: makeNumberSetting({
 		key: "dataLakeEmbeddingTierMultiplierIndividual",
@@ -9416,7 +10409,7 @@ const settingsMap = {
 		description: "Scales the per-run and per-lake embedding budgets for lakes owned by an individual user. 1 means those lakes get exactly the configured budgets; 0 stops them spending at all. The effective budget is still capped by the same hard rail as the untiered value.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.DATA_LAKE_COST.id,
-		order: 8
+		order: 9
 	}),
 	dataLakeEmbeddingTierMultiplierOrganization: makeNumberSetting({
 		key: "dataLakeEmbeddingTierMultiplierOrganization",
@@ -9427,7 +10420,7 @@ const settingsMap = {
 		description: "Scales the per-run and per-lake embedding budgets for lakes owned by an organization, which serve a whole team rather than one person. 0 stops org-owned lakes spending at all. The effective budget is still capped by the same hard rail as the untiered value.",
 		category: "AI",
 		group: API_SERVICE_GROUPS.DATA_LAKE_COST.id,
-		order: 9
+		order: 10
 	}),
 	slackSigningSecret: makeStringSetting({
 		key: "slackSigningSecret",
@@ -9529,6 +10522,7 @@ const settingsMap = {
 	}),
 	enableVoiceSession: makeBooleanSetting({
 		key: "enableVoiceSession",
+		userReadable: true,
 		name: "Enable Voice Session",
 		defaultValue: false,
 		description: "Whether to enable the voice session.",
@@ -9538,6 +10532,7 @@ const settingsMap = {
 	}),
 	voiceV2Enabled: makeBooleanSetting({
 		key: "voiceV2Enabled",
+		userReadable: true,
 		name: "Enable Voice v2 (Model-Agnostic)",
 		defaultValue: false,
 		description: "Gate for the Voice v2 feature (ElevenLabs Conversational AI + any B4M reasoning model). When disabled, /api/voice/v2/sessions returns 403.",
@@ -9557,6 +10552,7 @@ const settingsMap = {
 	}),
 	voiceSessionAiVoice: makeStringSetting({
 		key: "voiceSessionAiVoice",
+		userReadable: true,
 		name: "Default Assistant Voice",
 		defaultValue: "alloy",
 		description: "The default voice for the assistant in the voice session.",
@@ -9858,16 +10854,6 @@ const settingsMap = {
 		group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
 		order: 80
 	}),
-	EnableOptiHashiDefault: makeBooleanSetting({
-		key: "EnableOptiHashiDefault",
-		name: "OptiHashi: On by default for users",
-		defaultValue: false,
-		description: "When enabled, OptiHashi is active for users who have never explicitly toggled it.",
-		category: "Experimental",
-		group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
-		order: 81,
-		dependsOn: "EnableOptiHashi"
-	}),
 	EnableLibreOncology: makeBooleanSetting({
 		key: "EnableLibreOncology",
 		name: "Enable LibreOncology",
@@ -10068,6 +11054,7 @@ const settingsMap = {
 	}),
 	orchestrationDefaults: makeObjectSetting({
 		key: "orchestrationDefaults",
+		userReadable: true,
 		name: "Agent Orchestration Defaults",
 		defaultValue: OrchestrationDefaultsSchema.parse({}),
 		description: "Default ReAct profile for agentless executions (#8922). Drives allowed/denied tools, iteration ceilings, default thoroughness, and fallback models when the agent_executor is invoked without a persisted IAgent (e.g. the upcoming Agent-mode toggle).",
@@ -10138,6 +11125,15 @@ const settingsMap = {
 		group: API_SERVICE_GROUPS.MODEL_DISCOVERY.id,
 		order: 6
 	}),
+	modelDiscoveryProbeNewModels: makeBooleanSetting({
+		key: "modelDiscoveryProbeNewModels",
+		name: "Probe New Models for Dispatch",
+		defaultValue: true,
+		description: "Lets a write-mode run spend a forced one-tool call on a newly discovered OpenAI model to verify which token parameter and tool transport it takes, and turn its tools on. Off leaves every new OpenAI model with tools withheld until an operator writes the dispatch profile by hand.",
+		category: "AI",
+		group: API_SERVICE_GROUPS.MODEL_DISCOVERY.id,
+		order: 7
+	}),
 	prReportRepo: makeStringSetting({
 		key: "prReportRepo",
 		name: "PR Report Repository",
@@ -10230,7 +11226,8 @@ const ModelTelemetrySchema = z$1.object({
 		"google",
 		"xai",
 		"ollama",
-		"moonshot"
+		"moonshot",
+		"deepseek"
 	]),
 	fallbackUsed: z$1.boolean(),
 	fallbackReason: z$1.string().optional(),
@@ -10247,7 +11244,8 @@ const SystemPromptDetailSchema = z$1.object({
 		"user",
 		"project",
 		"session",
-		"org"
+		"org",
+		"caller"
 	]),
 	/** e.g., "date_context", "tool_guidance" */
 	name: z$1.string(),
@@ -10641,6 +11639,7 @@ const PromptMetaContextSchema = z$1.object({
 	}).optional(),
 	lakeMemory: z$1.object({
 		beliefCount: z$1.number(),
+		beliefBudget: z$1.number().optional(),
 		dataLakeTags: z$1.array(z$1.string())
 	}).optional(),
 	contextWindowUsage: z$1.object({
@@ -10685,7 +11684,15 @@ const PromptMetaPerformanceSchema = z$1.object({
 	totalResponseTime: z$1.number().optional(),
 	contextRetrievalTime: z$1.number().optional(),
 	modelInferenceTime: z$1.number().optional(),
+	/**
+	* Time to First Visible Token: elapsed ms until the first chunk the user can actually
+	* see. Left unset when a turn streamed nothing visible (thinking-only, or a turn that
+	* errored before answering), so absence reads as "never rendered" rather than as fast.
+	* Pair with firstChunkTime to tell a slow model from a long hidden-reasoning window.
+	*/
 	firstTokenTime: z$1.number().optional(),
+	/** Elapsed ms until the first chunk of any kind, including a hidden thinking block. */
+	firstChunkTime: z$1.number().optional(),
 	clientFirstTokenTime: z$1.number().optional(),
 	streamingPerformance: z$1.object({
 		chunkCount: z$1.number().optional(),
@@ -10766,11 +11773,16 @@ const CitableSourceSchema = z$1.object({
 * zero-result retrieval, so a turn that legitimately found nothing is indistinguishable from one
 * where retrieval never ran at all.
 *
-* Deliberately holds NO counts and NO chunk/document identifiers. Counts already exist and are
-* more precise: `citables.filter(c => c.type === 'document')` is deduped by id/url/title in
+* Holds NO chunk/document identifiers, and no DOCUMENT count. A document count already exists and
+* is more precise: `citables.filter(c => c.type === 'document')` is deduped by id/url/title in
 * `applyQuestStatusChanges`, while this shape cannot dedupe (no identifiers to dedupe by) and
-* would have to sum - producing a second, disagreeing number for the same question. Similarity
-* scores live on `LakeAccessEvent`, not here.
+* would have to sum - producing a second, disagreeing number for the same question.
+*
+* `injected` below is NOT that number and does not reopen it: it counts PASSAGES and characters,
+* neither of which `citables` can express - one document contributes many passages, and a turn
+* that injected nothing emits no citable to count at all. Similarity scores otherwise live on
+* `LakeAccessEvent`; the single `injected.topScore` is here because that row is written only on a
+* turn that grounded, so it cannot carry the near-miss score of a turn that grounded on nothing.
 *
 * CAUTION, not a guarantee: the absence of chunk/document identifiers is what keeps this shape
 * OUT of `promptMetaRedaction.ts`'s scope (that helper is a functionCalls-only denylist and would
@@ -10789,28 +11801,351 @@ const CitableSourceSchema = z$1.object({
 *
 * Absent-or-fully-present, matching `lakeMemory` above - see the Mongoose-side subSchema comment
 * in QuestModel.ts for why partial-write and default-array shapes are unsafe here.
+*
+* WIDER THAN ITS NAME SUGGESTS as of `mode` (#1394). The field is no longer written only when
+* retrieval ran: it is now seeded on every turn that could have retrieved (forced retrieval
+* enabled, or the knowledge tool offered), so `attempted: false` is a recorded fact rather than
+* an absence to be inferred. Presence therefore means "this turn was in a position to retrieve",
+* and turns with no knowledge in scope still carry no field at all. The distinction matters to a
+* rollup: absence is now ambiguous between "not a retrieval turn" and "written before this
+* existed", which is why `mode` documents its own date-bounding requirement.
 */
 const RetrievalSummarySchema = z$1.object({
 	/** True once a retrieval-capable surface actually ran (not merely offered) this turn. */
 	attempted: z$1.boolean(),
 	/**
+	* Present if and only if `attempted` is true - an outcome describes a run, and a turn that
+	* never ran retrieval has none. A reader testing for a specific value is unaffected (absence
+	* is not any of them); a reader switching exhaustively must handle undefined.
+	*
 	* 'ok' - ran, whether or not anything came back (the zero case is a legitimate 'ok').
 	* 'no_lakes' - ran but the user had no entitled/selected lake in scope.
-	* 'failed' - threw; recall did not complete.
-	* On multiple retrieval calls within one turn, merge priority is failed > ok > no_lakes (see
-	* retrievalSummaryMerge.ts's mergeRetrievalSummary): a single failure is never masked by a later
-	* success or abstain, and a real success on one surface is never masked by another surface's
-	* "no lakes in scope" abstain in the same turn.
+	* 'not_indexed' - ran to completion having compared nothing: the corpus in scope carries no
+	*   usable vector (never indexed, or embedded with a foreign model), so no passage was ever
+	*   scored against the query. Distinct from 'ok' because the library was not searched at all,
+	*   and reporting that as a topical zero ("your documents do not cover this") is exactly the
+	*   confident-wrong-answer this field exists to catch. Distinct from 'failed' because nothing
+	*   broke: the remedy is re-vectorizing, which the corpus owner can do themselves, and a retry
+	*   never helps.
+	*   COVERAGE: recorded by forced retrieval (KnowledgeRetrievalFeature's `scoredCount === 0`
+	*   exit) and by knowledgeBaseSearch, whose semantic arms carry the same verdict through to the
+	*   keyword arm's write - the two agree on "not one passage was compared against the query",
+	*   not on any withholding flag, so a relevance floor that emptied a real search and a partial
+	*   withholding alongside a real search both stay 'ok' on both surfaces.
+	*   knowledgeBaseRetrieve cannot reach this state: it fetches named files rather than ranking
+	*   against a query embedding, so it has no comparison to come up empty.
+	* 'failed' - recall did not complete: it threw, OR the retrieval repository is not wired on
+	*   this host (the guards in ChatCompletionFeatures / knowledgeBaseSearch / knowledgeBaseRetrieve
+	*   record it without anything throwing). What separates it from 'not_indexed' is the remedy,
+	*   not the tempo: fix the outage or the host wiring, never re-index content. An unwired host
+	*   reports continuously too, so "chronic" alone does not pick out 'not_indexed'.
+	*   NOT this: a model-supplied argument that is not a well-formed id. knowledgeBaseRetrieve
+	*   shape-checks `file_id` and answers a malformed one as a single-file miss ('ok'), because the
+	*   remedy is for the model to search for the right id - there is nothing for an operator to
+	*   fix. It is logged rather than counted here, so the rate stays observable without this field
+	*   reporting an outage that is not happening.
+	* On multiple retrieval calls within one turn, merge priority is failed > not_indexed > ok >
+	* no_lakes (see retrievalSummaryMerge.ts's mergeRetrievalSummary): a single failure is never
+	* masked by a later success or abstain, an unsearchable corpus outranks a legitimate zero so a
+	* success on another surface cannot erase it, and a real success is never masked by another
+	* surface's "no lakes in scope" abstain in the same turn.
 	*/
 	outcome: z$1.enum([
 		"ok",
 		"no_lakes",
+		"not_indexed",
 		"failed"
-	]),
+	]).optional(),
+	/**
+	* Whether forced retrieval was ENABLED for this turn, independent of whether it then ran.
+	*
+	* This is what makes the optional path measurable. `attempted` says retrieval happened;
+	* without `mode` there is no way to ask the complementary question - of the turns where the
+	* model was merely OFFERED the knowledge tools, how often did it choose to retrieve - because
+	* a forced turn and an optional turn both land as `attempted: true`.
+	*
+	* Optional on the schema, and absence NEVER means 'optional' - it means unclassified. Two
+	* sources, one historical and one ongoing: turns recorded before this field landed, and
+	* agent-mode runs, which write a retrieval summary through `persistRunAsQuest` but never pass
+	* the seed site at the `offeredTools` write in ChatCompletionProcess. So date-bounding a rollup
+	* removes the first source but not the second; count the unclassified bucket rather than
+	* assuming it empties.
+	*/
+	mode: z$1.enum(["forced", "optional"]).optional(),
+	/**
+	* Whether the knowledge-base when-to-retrieve guidance section actually shipped in this turn's
+	* tool prompt. Written only on turns that were OFFERED the knowledge tool, so absence means
+	* "not an offered turn" or "recorded before this field landed" - it never means "cleared".
+	*
+	* `false` is the load-bearing value here, not filler. Clearing the KnowledgeBaseRetrievalPrompt
+	* setting is the section's only off switch, so a turn recording `false` is the CONTROL arm of
+	* the A/B this field exists to make readable. Anything merging or folding this must preserve an
+	* explicit `false` rather than collapse it into absent - see mergeRetrievalSummary, which uses
+	* `??` and deliberately not `||` for that reason.
+	*
+	* MUST STAY IN SYNC with TWO gates, not one. ToolBuilder.buildToolPrompt emits the section iff
+	* the tool is offered AND the guidance string is non-empty; filterByPromptMode then drops the
+	* whole `toolPrompt` source, which no promptMode admits, so an offered tool is not sufficient.
+	* The ChatCompletionProcess seed site conjoins all three, and hands the first two to
+	* buildToolPrompt as the same consts, so the flag and the actual emission cannot drift.
+	*/
+	knowledgeBaseGuidanceInjected: z$1.boolean().optional(),
+	/**
+	* Why the forced arm did not run on a turn that had it enabled. Only ever set with
+	* `mode: 'forced'`, and only for the deliberate suppressions in
+	* ChatCompletionFeatures.getContextMessages - a forced turn that ran and failed reports that
+	* through `outcome`, not here.
+	*
+	* These turns are the reason this field exists: forced retrieval is configured, a rule
+	* suppresses it, and the model falls back to the offered tool. That is exactly the population
+	* the per-turn routing question is about, and before this it was indistinguishable from a turn
+	* where forced retrieval was never configured at all.
+	*/
+	forcedSkipReason: z$1.enum(["attached_files", "personal_corpus"]).optional(),
 	/** Which retrieval-capable surface(s) ran this turn, e.g. 'lake-memory', 'knowledgeBaseSearch'. */
 	surfaces: z$1.array(z$1.string()),
 	/** Lakes resolved at the moment retrieval ran, stamped point-in-time (not read live from the session). */
-	dataLakeTags: z$1.array(z$1.string())
+	dataLakeTags: z$1.array(z$1.string()),
+	/**
+	* The lake scope the turn's retrieval surfaces WOULD have searched, resolved at the seed site
+	* whether or not any of them ran: the caller's accessible lakes narrowed to the session
+	* (narrowLakeAccessToSession), or empty where the corpus is personal and the lake arms are
+	* suppressed. `dataLakeTags` is the other half of the pair and answers a different question -
+	* which lakes retrieval ACTUALLY used - so on a turn where retrieval never ran that one is empty
+	* while this one still names whatever was in scope.
+	*
+	* EXISTS FOR THE OFFLINE REPLAY. `answerability` is reconstructed after the fact, and without a
+	* recorded scope the replay had to rebuild one from the session's `retrievalTags` as they stand
+	* at replay time - a session whose lake selection had since changed was replayed against a
+	* corpus its turn never had, with nothing to flag it. Recording it here removes that drift for
+	* every turn seeded after this landed; `probedAt` still discloses the content drift, which no
+	* amount of recording can fix.
+	*
+	* Absence means NOT RECORDED (a turn predating this, or one whose `retrieval` was written only
+	* by a surface rather than by the seed) - never "no lakes in scope", which is present-and-empty.
+	* The replay must keep those apart: probing an unrecorded turn would mean inventing a scope,
+	* which is the approximation this field exists to end.
+	*
+	* Only the seed writes it, so mergeRetrievalSummary carries it first-writer-wins rather than
+	* unioning: a later surface write asserting a narrower scope must not be able to widen the
+	* recorded one, and a union across the two would mean neither.
+	*/
+	lakeScope: z$1.array(z$1.string()).optional(),
+	/**
+	* Ids of the lakes whose `systemPrompt` was injected this turn (getAccessibleDataLakePrompts),
+	* across every injection site (forced retrieval and the model-driven knowledge tools). NOT the
+	* prompt text itself - that already reaches the model in the completion, and copying it here
+	* widens exposure for nothing. Absent means no injection site ran; present-and-empty means one
+	* ran but nothing qualified (untrusted, or an empty systemPrompt).
+	*/
+	injectedLakePromptIds: z$1.array(z$1.string()).optional(),
+	/** mementoCount/mementoIds precedent: mirrors injectedLakePromptIds.length. */
+	injectedLakePromptCount: z$1.number().optional(),
+	/**
+	* How much retrieved content actually reached the model this turn: `chunks` passages totalling
+	* `chars` characters of retrieved CONTENT (headings and framing excluded, so the number means
+	* the same thing on every surface), plus `topScore`, the best similarity among the compared
+	* passages the reporting surface can SEE - which is not the same population on every surface.
+	* Forced retrieval scores every chunk itself and so reports true near-misses; knowledgeBaseSearch's
+	* semantic arm only ever sees `minScore` survivors, and reports no `topScore` at all on a starve,
+	* so a sub-floor near-miss there is invisible rather than recorded.
+	*
+	* PRESENCE CONTRACT: present if and only if at least one surface COMPLETED a search this turn.
+	* `chunks: 0` is a RECORDED STARVE - the library was searched and nothing was injected, which is
+	* the case this field exists to make visible: without it, a forced-retrieval turn that injected
+	* nothing is byte-identical to one that injected its whole character budget (both `outcome:
+	* 'ok'`). Absence means the volume is UNKNOWN, which is what a turn carries when no surface
+	* completed a search: retrieval was never attempted, nothing was in scope to search
+	* ('no_lakes'), or the one surface that ran broke mid-flight, where a zero would be a lie.
+	* A surface that completed but CANNOT know the turn's passage volume also stays silent rather
+	* than claiming a zero - knowledgeBaseSearch's keyword arm on a hit is the case: it injects
+	* file metadata and hands the model retrieve_knowledge_content, which injects the text and
+	* reports no volume, so its zero would survive the merge as a starve that did not happen.
+	*
+	* KNOWN HOLE in that rule, while retrieve_knowledge_content stays uninstrumented: a recorded zero
+	* is not PROOF of a starve. Forced retrieval and the knowledge tools are not mutually exclusive
+	* (ChatCompletionProcess seeds on `forcedRetrievalEnabled || knowledgeToolOffered`), so the forced
+	* arm can complete empty, write its honest zero, and the model can then ground the same turn
+	* through retrieve_knowledge_content, which contributes no volume to oppose it. The zero is
+	* per-surface-truthful and turn-level-misleading. Any rollup counting starves should treat a zero
+	* as "nothing was injected by a surface that reports volume" and, until that tool reports its own,
+	* cross-check `functionCalls` before calling the turn ungrounded.
+	*
+	* Per SURFACE, not per turn: a surface that breaks contributes nothing while a surface that
+	* completed alongside it still reports its own volume, so a turn CAN read 'failed' next to a
+	* recorded zero. That pairing means "one surface broke, and everything that did finish injected
+	* nothing" - which is exactly what a reader needs, and strictly more than the outcome alone.
+	*
+	* SUMMED across surfaces, so this field and `outcome` can legitimately disagree in tone on a
+	* multi-surface turn: forced retrieval grounding on 12 passages while knowledgeBaseSearch throws
+	* gives `outcome: 'failed'` alongside `chunks: 12`. That is correct - `outcome` is worst-of,
+	* `injected` is sum-of-completions.
+	*
+	* `topScore` is optional because only cosine-similarity surfaces have one to report. Lake
+	* memory's belief `relevance` is a different scale and forced retrieval's pre-scan value is a
+	* -1 sentinel; neither is ever written here, because a `max` across mixed scales, or against a
+	* sentinel, is a number that reads as a similarity and is not one.
+	*
+	* Date-bound any rollup, the same caveat `mode` documents on itself: turns recorded before this
+	* landed carry no volume, and no backfill is possible - the volume of a past turn is gone.
+	*
+	* `preRelativeFloorCandidates` and `postRelativeFloorCandidates` are the ONE pair here that is
+	* not "what reached the model": `ranked.length` and `scored.length` in KnowledgeRetrievalFeature
+	* - the candidates left after the absolute similarity floor, and after the relative floor
+	* trims them. `chunks` is what survived the char budget on top of that, so the three
+	* numbers bracket two independent trimmers:
+	*
+	*   pre -> [relative floor] -> post -> [char budget] -> chunks
+	*
+	* They exist so a low `chunks` is diagnosable - a small corpus and a floor that trimmed a large
+	* pool end in the same `chunks`. `pre - post` is the floor's own effect and nothing else;
+	* `pre - chunks` is NOT, because the budget trims the same walk. Both optional: only forced
+	* retrieval computes a ranked pool, a surface without one (lake memory, the knowledge tools)
+	* never writes either, and absence must not read as zero candidates. SUMMED like `chunks`, with
+	* the same absent-is-not-zero handling as `topScore`.
+	*
+	* COMPARE THE PAIR ONLY TO ITSELF, never to `chunks`, unless `surfaces` is forced retrieval
+	* alone. `chunks` and `chars` sum across ALL surfaces while this pair is forced-only, so a mixed
+	* turn can store `chunks` above `pre` - inverting the relationship the pair exposes. Lake memory
+	* is the common case, not the exotic one: it is enabled inside the same forced-retrieval gate,
+	* so on a lake-memory lake it writes on nearly every forced turn. Its chunks can be backed out
+	* via `context.lakeMemory.beliefCount` (approximately - that count is pre-sanitization); its
+	* CHARS land only inside the shared sum, with no per-surface field to subtract them back out, so
+	* `chars` cannot be decontaminated at all. `pre - post` needs neither, which is the point of
+	* storing both.
+	*
+	* BOTH SATURATE, so `pre` counts what the SCAN REACHED, not what the corpus holds: `pool` is
+	* truncated in-scan at FORCED_RETRIEVAL_MAX_SCORED_CHUNKS (256), over a scan itself bounded by
+	* FORCED_RETRIEVAL_MAX_SCANNED_CHUNKS (4000) across FORCED_RETRIEVAL_MAX_CANDIDATE_FILES (100).
+	* 2000 qualifying chunks and 300 both record 256; above the cap a rollup is a plateau.
+	*/
+	injected: z$1.object({
+		chunks: z$1.number(),
+		chars: z$1.number(),
+		topScore: z$1.number().optional(),
+		preRelativeFloorCandidates: z$1.number().optional(),
+		postRelativeFloorCandidates: z$1.number().optional()
+	}).optional(),
+	/**
+	* Could the corpus in scope have answered this turn, whether or not the model went looking?
+	*
+	* The denominator the optional-path retrieval rate has always been missing (#1394). A rate of
+	* "the model retrieved on 20% of offered turns" cannot say whether the other 80% were misses or
+	* turns with nothing to find, and the two argue for opposite things: the first for routing work,
+	* the second for leaving the optional path alone. Crossing this field with the rate separates
+	* them.
+	*
+	* THE ONLY FIELD IN THIS BLOCK NOT WRITTEN BY THE TURN. Every sibling is stamped point-in-time
+	* while the turn runs; this one is written afterwards by an offline replay
+	* (packages/scripts/retrieval/answerability-replay.ts) that re-scores the recorded prompt against
+	* the corpus. That is deliberate - the population it exists to measure is the turns where
+	* retrieval did NOT run, so computing it live would mean adding a full brute-force chunk scan
+	* (ChatCompletionFeatures' forced path, which has no ANN index) to exactly the turns that pay
+	* nothing for retrieval today. The measurement is not worth that latency on live traffic.
+	*
+	* BEING A RECONSTRUCTION, IT CARRIES DRIFTS THE OTHER FIELDS DO NOT:
+	* 1. Corpus CONTENT moves. A document added or reindexed between the turn and the replay is
+	*    scored as though it had been there. `probedAt` discloses the gap; a replay run long after
+	*    the window is weak evidence, not strong.
+	* 2. Corpus SCOPE no longer drifts: the seed records the turn's resolved scope in `lakeScope`
+	*    and the replay probes that, so a session whose lake selection has since changed is still
+	*    scored against the lakes its turn actually had. The cost is coverage rather than accuracy -
+	*    a turn with no recorded scope is skipped instead of approximated, so every turn predating
+	*    the field is outside the measurement.
+	* 3. The QUESTION can move out from under it. The probe is keyed to the quest, not to the
+	*    prompt text it scored, so a turn whose prompt is later rewritten in place keeps a probe
+	*    describing the question it used to ask. mergeRetrievalSummary preserves the probe across
+	*    a runtime write deliberately - dropping it would erase the backfill - so nothing
+	*    invalidates a stale one. Re-run the replay with --force over a window whose turns were
+	*    edited.
+	*
+	* RAW SCORE, NOT A VERDICT, so the cutoff lives in the reader. summarizeOptionalPathRetrieval
+	* applies it at fold time, which lets the same replay be re-thresholded without re-running -
+	* the point of storing the number, given the two live floors disagree by construction (forced
+	* retrieval's absolute default is 0.75, the knowledge tool's is 0).
+	*
+	* `topScore` is the same raw cosine scale as `injected.topScore` and comparable to it. It is NOT
+	* comparable to lake memory's belief relevance, for the reason `injected` documents at length.
+	*
+	* `scanTruncated` inherits forced retrieval's saturation: the replay bounds its scan the same
+	* way, so a low `topScore` on a truncated scan is not proof the corpus lacked an answer - it is
+	* proof the part that was scanned did. Treat those turns as unknown rather than as negatives.
+	*
+	* Absence means NOT PROBED - never "not answerable". Every turn predating the replay, and every
+	* turn the replay skipped or failed on, is absent, so a fold must keep it as its own arm rather
+	* than letting it fall in with the negatives.
+	*/
+	answerability: z$1.object({
+		/** Best cosine the replay found across the reconstructed corpus. */
+		topScore: z$1.number(),
+		/** Chunks at or above `floor`. Separates "one lucky match" from "a rich seam". */
+		candidatesAboveFloor: z$1.number(),
+		/** The absolute floor the replay counted `candidatesAboveFloor` against, as a fraction. */
+		floor: z$1.number(),
+		/** The scan hit its chunk ceiling, so `topScore` is a floor on the true best, not the best. */
+		scanTruncated: z$1.boolean(),
+		/** When the replay ran, NOT when the turn ran - the disclosure for content drift above. */
+		probedAt: JsonSafeDate
+	}).optional(),
+	/**
+	* Which of this turn's injected lake prompt ids were BOTH in the session's pre-authorized (manage-
+	* but-not-member admission) set AND injected on this turn - see unionPreauthorizedLakeAccess and
+	* pages/api/sessions/create.ts. A subset of injectedLakePromptIds, never a superset. Narrows the
+	* session's static `preauthorizedLakeIds` (what was ADMITTED) to what a given turn actually used.
+	*
+	* MEMBERSHIP, NOT CAUSATION. An admitted lake the caller could already reach - its creator, or a
+	* member of its org - injects through the ordinary trust arm and is listed here all the same, so a
+	* non-empty value does not prove the admission is what made the injection possible. Absent means no
+	* admitted id was among this turn's injections, including every turn on a session with none.
+	*/
+	preauthorizedLakeIdsUsed: z$1.array(z$1.string()).optional(),
+	/**
+	* Which of this turn's injected lake prompt ids the caller holds an owner/curator GRANT on - the
+	* per-arm sibling of `preauthorizedLakeIdsUsed`, and the reason both exist: `injectedLakePromptIds`
+	* records THAT a lake's systemPrompt entered the turn, these two record WHICH ARM admitted it.
+	* A subset of injectedLakePromptIds, never a superset. Derived at both injection sites via
+	* grantedLakeIdsUsedFor.
+	*
+	* THE ARM WORTH NAMING SEPARATELY: the grant arm (#2495) is the only one that can cross an org
+	* boundary - `grantLakeAccess` can hand a CURATOR grant to an arbitrary cross-tenant user, and
+	* that grant carries injection trust. The creator and org arms cannot reach past one org, and a
+	* reader grant is excluded permanently, so a lake listed here is the case an operator auditing
+	* cross-tenant prompt influence is actually looking for.
+	*
+	* MEMBERSHIP, NOT CAUSATION, the same caveat the field above carries: a granted lake its holder
+	* could already reach (they created it, or they are in its org) injects through the ordinary
+	* trust arm and is listed here anyway, so a non-empty value does not prove the grant is what
+	* made the injection possible. The two fields OVERLAP for that reason - a lake can appear in
+	* both - so they are not a partition of injectedLakePromptIds and must not be counted as one.
+	*
+	* Absent means no injected id was grant-reached, including every turn where the grant read
+	* FAILED (it is fail-quiet by design - telemetry must not drop the injection it records), so
+	* absence is weaker evidence than presence. Date-bound any rollup: turns predating this field
+	* carry nothing, and no backfill is possible - a past turn's grant rows have moved on.
+	*/
+	grantedLakeIdsUsed: z$1.array(z$1.string()).optional()
+});
+/**
+* Why a grounded turn's library scan stopped short of the whole library.
+*
+* Written ONLY on a partially-covered turn (reportCoverage returns early otherwise), so presence
+* means "partial" and `partial` is always true - the flag is explicit anyway because a reader
+* checking `retrievalCoverage.partial` should not have to know that absence is the other half of
+* the contract.
+*
+* Single producer (ChatCompletionFeatures.reportCoverage), which is why - unlike `warnings`,
+* `citables` and `retrieval` - this field needs no merge case in applyQuestStatusChanges: a
+* later tool-arm write that omits it is preserved by the one-level spread.
+*
+* `reasons` is the same diagnostic prose the warnings entry interpolates. It is shown to the
+* reader behind a disclosure rather than in the banner body, because only some reasons are
+* actionable (a document mid-reindex returns on its own; a per-turn chunk budget does not).
+*/
+const RetrievalCoverageSchema = z$1.object({
+	/** Always true - see the presence contract above. */
+	partial: z$1.boolean(),
+	/** One entry per distinct cause, e.g. a candidate cap, a scan budget, an embedding mismatch. */
+	reasons: z$1.array(z$1.string())
 });
 z$1.object({
 	model: PromptMetaModelSchema.optional(),
@@ -10820,6 +12155,9 @@ z$1.object({
 	* deliberately: applyQuestStatusChanges does a one-level spread merge, so a field nested under
 	* `context` would be replaced wholesale by any tool-arm write instead of merging. */
 	retrieval: RetrievalSummarySchema.optional(),
+	/** Partial-grounding-coverage detail - see RetrievalCoverageSchema. Top-level for the same
+	* one-level-spread-merge reason as `retrieval` above. */
+	retrievalCoverage: RetrievalCoverageSchema.optional(),
 	functionCalls: z$1.array(PromptMetaFunctionCallSchema).optional(),
 	/**
 	* Names of the tools actually offered to the model this turn - the output of `buildTools`
@@ -11513,6 +12851,7 @@ z.object({
 	requiredUserTag: z.union([z.literal(""), z.string().min(1).max(100)]).optional(),
 	requiredEntitlement: z.union([z.literal(""), z.string().min(3).max(100).refine((s) => s.includes(":") && s.split(":").every((part) => part.length > 0), "Entitlement key must be namespaced with non-empty parts (e.g. \"product:pro\")")]).optional(),
 	auditQueryTextEnabled: z.boolean().optional(),
+	lakeMemoryEnabled: z.boolean().optional(),
 	requiredPassageTokenTarget: z.number().int().min(64).max(OVERSIZED_PASSAGE_TOKEN_THRESHOLD).nullable().optional()
 });
 z.object({
@@ -11587,6 +12926,7 @@ tags: z.array(TaxonomyTagInput).max(100) });
 z.object({ 
 /** User description of the data (helps the AI) */
 context: z.string().max(2e3).optional() });
+z.object({ tags: z.array(z.string().min(1).max(130).regex(/^[^\r\n]*$/)).max(100) });
 z.object({ hashes: z.array(z.string().regex(sha256Regex)).min(1).max(500) });
 const SyncDeltaFileEntry = z.object({
 	relativePath: z.string(),
@@ -11618,55 +12958,6 @@ z.object({
 		skip: z.array(z.string())
 	})
 });
-z$1.enum([
-	"inject",
-	"auto-fire",
-	"hidden"
-]);
-/**
-* Modes acceptable at AUTHORING time. 'hidden' is intentionally excluded until
-* the host has true hidden-send support - accepting it would persist a value
-* that silently behaves as 'auto-fire' (a surprising downgrade). It stays in
-* ExecutionModeSchema/the stored enum for forward-compat.
-*/
-const AuthorableExecutionModeSchema = z$1.enum(["inject", "auto-fire"]);
-/**
-* Tools a prompt may require - constrained to the host's closed tool set, MINUS
-* integration-gated tools that act on the caller's own credentials/account. A
-* shared system prompt must not be able to inject e.g. blog-publishing into a
-* non-author's session via requiredTools. (Per-user entitlement of the remaining
-* tools is still the chat pipeline's responsibility - see follow-up note in the
-* briefcase blueprint; this allowlist is the storage-layer floor.)
-*/
-const BRIEFCASE_DISALLOWED_TOOLS = [
-	"blog_publish",
-	"blog_edit",
-	"blog_draft"
-];
-const BriefcaseRequiredToolsSchema = z$1.array(b4mLLMTools.refine((t) => !BRIEFCASE_DISALLOWED_TOOLS.includes(t), "This tool is not permitted in a briefcase prompt")).max(16);
-z$1.string().regex(/^[a-f0-9]{24}$/i, "Invalid prompt id");
-const PROMPT_TEXT_MAX = 16e3;
-const TAGS_MAX = 20;
-z$1.object({
-	type: z$1.string().min(1).max(100),
-	name: z$1.string().min(1).max(200),
-	description: z$1.string().max(500).optional(),
-	promptText: z$1.string().min(1).max(PROMPT_TEXT_MAX),
-	tags: z$1.array(z$1.string().min(1).max(50)).max(TAGS_MAX).optional(),
-	executionMode: AuthorableExecutionModeSchema.optional(),
-	requiredTools: BriefcaseRequiredToolsSchema.optional()
-}).partial();
-/**
-* One catalog sub-query. Exactly one selector is used, in precedence order:
-* `personal` (resolved to the caller server-side) > `tags` > `type`.
-*/
-const PromptBatchQuerySchema = z$1.object({
-	key: z$1.string().min(1).max(100),
-	tags: z$1.array(z$1.string().min(1).max(50)).max(TAGS_MAX).optional(),
-	type: z$1.string().max(100).optional(),
-	personal: z$1.boolean().optional()
-});
-z$1.object({ queries: z$1.array(PromptBatchQuerySchema).min(1).max(32).refine((qs) => new Set(qs.map((q) => q.key)).size === qs.length, { message: "Batch query keys must be unique" }) });
 z$1.string().regex(/^[a-f0-9]{24}$/i, "Invalid template id");
 /**
 * The bound model. Reuses the legacy-remap preprocess so a template saved under
@@ -11969,6 +13260,31 @@ z$1.object({
 		"grounded",
 		"surface"
 	]).optional(),
+	/**
+	* Suppress OUR server-side auto-offers without entering a promptMode. Exists because promptMode
+	* was the only switch for the offer and it also strips every authored prompt, so no caller could
+	* have an arm that went unoffered AND kept the abstention licence.
+	*
+	* Gates the three auto-add sites (the knowledge offer in resolveEnabledTools, the navigate_view
+	* auto-add, the blog/skill gate), unioned with `Boolean(promptMode)` by
+	* resolveSkipAutoOffers. A force-on, not an override: `false` under a promptMode still suppresses.
+	* Withholding navigate_view also drops the viewRegistry system block, which only describes it.
+	*
+	* Withholds the OFFER, not knowledge: `session.forceKnowledgeRetrieval` is untouched, and an
+	* already-attached corpus is inlined rather than deferred to the tool. An arm that must see no
+	* knowledge at all also needs a session with no attachments and forced retrieval off.
+	*/
+	skipAutoOffers: z$1.boolean().optional(),
+	/**
+	* Caller-supplied system-prompt text. Rendered as a defended, deference-postured block
+	* appended last in the system-prompt stack. Reached by both POST /api/chat and /api/ai/llm.
+	*
+	* This cap is the universal backstop, not a duplicate of a route check: the parse that opens
+	* invoke() runs outside any try and before a quest row is written, so it holds for every caller
+	* including ones that pass through no route schema. Do not drop it on the assumption that
+	* whoever called validated first.
+	*/
+	systemPrompt: z$1.string().max(PROMPT_TEXT_MAX).optional(),
 	/** Whether Mementos is enabled */
 	enableMementos: z$1.boolean().optional(),
 	/** Whether Artifacts is enabled */
@@ -12942,7 +14258,7 @@ Array.from(new Set([
 		id: "opti.root",
 		section: "opti",
 		label: "OptiHashi Home",
-		description: "The OptiHashi Optimizer landing page showing all 8 pattern family cards",
+		description: "The OptiHashi Optimizer landing page showing the pattern family cards",
 		navigationType: "route",
 		target: "/opti",
 		keywords: [
@@ -13843,6 +15159,66 @@ Array.from(new Set([
 	const [, top] = v.target.split("/");
 	return `/${top}`;
 })));
+function getHeader(headers, name) {
+	if (!headers || typeof headers !== "object") return null;
+	if (typeof headers.get === "function") {
+		const value = headers.get(name);
+		return typeof value === "string" ? value : null;
+	}
+	const value = headers[name] ?? headers[name.toLowerCase()];
+	return typeof value === "string" ? value : null;
+}
+function parseCount(value) {
+	if (value === null) return null;
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	const parsed = Number(trimmed);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+const UNIT_MS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5
+};
+const DURATION_PART = /(\d+(?:\.\d+)?)(ms|h|m|s)/g;
+/**
+* Parse a Go-style duration ("6ms", "0s", "1m30s", "1h2m3s") to milliseconds.
+*
+* Exported for its own tests: it is the part of this module that can be wrong in a way the
+* numbers still look plausible.
+*/
+function parseDurationMs(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	DURATION_PART.lastIndex = 0;
+	let total = 0;
+	let matched = 0;
+	let consumed = 0;
+	for (const part of trimmed.matchAll(DURATION_PART)) {
+		total += Number(part[1]) * UNIT_MS[part[2]];
+		consumed += part[0].length;
+		matched += 1;
+	}
+	if (matched === 0 || consumed !== trimmed.length) return null;
+	return total;
+}
+/** Read both rate-limit dimensions off a provider response. */
+function parseEmbeddingRateLimitHeaders(headers) {
+	return {
+		limitTokens: parseCount(getHeader(headers, "x-ratelimit-limit-tokens")),
+		limitRequests: parseCount(getHeader(headers, "x-ratelimit-limit-requests")),
+		remainingTokens: parseCount(getHeader(headers, "x-ratelimit-remaining-tokens")),
+		remainingRequests: parseCount(getHeader(headers, "x-ratelimit-remaining-requests")),
+		resetTokensMs: parseDurationMs(getHeader(headers, "x-ratelimit-reset-tokens")),
+		resetRequestsMs: parseDurationMs(getHeader(headers, "x-ratelimit-reset-requests"))
+	};
+}
+/** True when the provider reported at least one usable ceiling. */
+function hasUsableLimits(snapshot) {
+	return snapshot.limitTokens !== null || snapshot.limitRequests !== null;
+}
 dayjs.extend(utc);
 dayjs.extend(timezone);
 dayjs.extend(relativeTime);
@@ -13911,16 +15287,34 @@ function isUserInitiatedAbort(error, userSignal) {
 	return isAbortError && !userSignal;
 }
 /**
-* Extract retry delay from error response (e.g., Retry-After header)
+* A Retry-After hint is only useful if it asks us to wait. `Retry-After: 0`, a negative value, or an
+* HTTP date that has already passed all carry no timing information - and every `withRetry` in this
+* repo treats a non-null hint as authoritative *over* its exponential backoff, so returning 0 does
+* not mean "wait a moment", it means "abandon the backoff entirely and retry immediately".
+*
+* That inverts the retry budget exactly when it matters: a server sends Retry-After when it is
+* already struggling, so honouring a zero turns the remaining attempts into an instant burst against
+* a service asking for room. Null instead, so the caller falls through to its own backoff.
+*
+* Exported because the rule, not the code, is the thing worth sharing: `Retry-After` is parsed in
+* more than one package (fab-pipeline's `getOpenSearchRetryAfterMs`), and a four-token predicate
+* copied around is a rule that drifts. Feed it a delay already converted to ms.
+*/
+function retryAfterHintOrNull(ms) {
+	return ms > 0 ? ms : null;
+}
+/**
+* Extract retry delay from error response (e.g., Retry-After header). Returns null when the header is
+* absent, unparseable, or does not ask us to wait - see retryAfterHintOrNull.
 */
 function getRetryAfterMs(error) {
 	if (!isAxiosError(error)) return null;
 	const retryAfter = error.response?.headers?.["retry-after"];
 	if (!retryAfter) return null;
 	const seconds = parseInt(retryAfter, 10);
-	if (!isNaN(seconds)) return seconds * 1e3;
+	if (!isNaN(seconds)) return retryAfterHintOrNull(seconds * 1e3);
 	const date = Date.parse(retryAfter);
-	if (!isNaN(date)) return Math.max(0, date - Date.now());
+	if (!isNaN(date)) return retryAfterHintOrNull(date - Date.now());
 	return null;
 }
 /**
@@ -15335,4 +16729,4 @@ var ConfigStore = class {
 	}
 };
 //#endregion
-export { VoyageAIEmbeddingModel as $, HTTPError as A, resolveHistoryFetchLimit as At, PermissionDeniedError as B, isNearLimit as Bt, DEFAULT_MUSIC_MODEL_ID as C, isRetryableError as Ct, FIXED_TEMPERATURE_MODELS as D, isZodError as Dt, FIELD_GROUP_OF as E, isUserInitiatedAbort as Et, ModelBackend as F, usdToCredits as Ft, SpeechToTextModels as G, REASONING_SUPPORTED_MODELS as H, NO_TEMPERATURE_MODELS as I, usdToCreditsStochastic as It, TooManyRequestsError as J, SupportedFabFileMimeTypes as K, NotFoundError as L, withRetry as Lt, ImageModels as M, settingsMap as Mt, InternalServerError as N, toModelInfo as Nt, FORMAT_PROMPT_TEMPLATE as O, mapMimeTypeToArtifactType as Ot, MODEL_INFO_FIELD_GROUP_OF as P, toModelRecord as Pt, VideoModels as Q, OllamaEmbeddingModel as R, buildRateLimitLogEntry as Rt, CorruptedFileError as S, isRenderableModelType as St, DEGENERATE_FINISH_REASON as T, isUnlimitedHistory as Tt, REFUSAL_FALLBACK_MODELS as U, REASONING_EFFORT_INCOMPATIBLE_WITH_TOOLS_MODELS as V, parseRateLimitHeaders as Vt, RESPONSES_API_TOOL_MODELS as W, UnprocessableEntityError as X, UnauthorizedError as Y, VIDEO_SIZE_CONSTRAINTS as Z, BadRequestError as _, isImageServeable as _t, getCreditsUrl as a, getMcpProviderMetadata as at, CREDIT_DEDUCT_TRANSACTION_TYPES as b, isModelDeprecated as bt, requireApiUrl as c, isAudioMimeType as ct, AGENT_QUEST_MANIFEST as d, isEarlyStop as dt, WORK_ITEM_STATUSES as et, AGENT_QUEST_MCP_URI as f, isFieldGroup as ft, BFL_SAFETY_TOLERANCE as g, isImageAttachment as gt, BEDROCK_NO_PROMPT_CACHING_MODELS as h, isGeminiModelId as ht, LOCAL_DEV_URL as i, defaultEmbeddingModelForEnv as it, HttpStatus as j, secureParameters as jt, ForbiddenError as k, obfuscateApiKey as kt, resolveApiEndpoint as l, isChunkRebuildPending as lt, ApiKeyType as m, isGPTImageModel as mt, logger as n, calculateRetryDelay as nt, getEnvironmentName as o, getQuestErrorCode as ot, ARTIFACT_ATTRS_PATTERN as p, isGPTImage2Model as pt, TTS_MAX_INPUT_CHARS as q, ApiEndpointUnconfiguredError as r, dayjsConfig_default as rt, parseApiUrl as s, getRetryAfterMs as st, ConfigStore as t, applyModelPriceCatalog as tt, AGENT_QUEST_ID as u, isConvergencePausedNote as ut, BedrockEmbeddingModel as v, isMediaModelType as vt, DEFAULT_UNKNOWN_CONTEXT_WINDOW as w, isSupportedFabFileMimeType as wt, ChatModels as x, isPlaceholderApiKey as xt, CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS as y, isModelAccessible as yt, OpenAIEmbeddingModel as z, extractSnippetMeta as zt };
+export { SupportedFabFileMimeTypes as $, selfClaimedActorKindSchema as $t, HTTPError as A, isPlaceholderApiKey as At, OPENAI_GPT_IMAGE_1_IMAGE_SIZES as B, reservationOutputTokens as Bt, DEFAULT_MUSIC_MODEL_ID as C, isGPTImageModel as Ct, FIXED_TEMPERATURE_MODELS as D, isMediaModelType as Dt, FIELD_GROUP_OF as E, isImageServeable as Et, MODEL_INFO_FIELD_GROUP_OF as F, isUserInitiatedAbort as Ft, PermissionDeniedError as G, toModelRecord as Gt, OllamaEmbeddingModel as H, secureParameters as Ht, McpServerName as I, isZodError as It, REFUSAL_FALLBACK_MODELS as J, withRetry as Jt, REASONING_EFFORT_INCOMPATIBLE_WITH_TOOLS_MODELS as K, usdToCredits as Kt, ModelBackend as L, mapMimeTypeToArtifactType as Lt, IMAGE_SIZE_CONSTRAINTS as M, isRetryableError as Mt, ImageModels as N, isSupportedFabFileMimeType as Nt, FORMAT_PROMPT_TEMPLATE as O, isModelAccessible as Ot, InternalServerError as P, isUnlimitedHistory as Pt, SpeechToTextModels as Q, actorKindSchema as Qt, NO_TEMPERATURE_MODELS as R, obfuscateApiKey as Rt, CorruptedFileError as S, isGPTImage2Model as St, DEGENERATE_FINISH_REASON as T, isImageAttachment as Tt, OpenAIEmbeddingModel as U, settingsMap as Ut, OPENAI_GPT_IMAGE_2_IMAGE_SIZES as V, resolveHistoryFetchLimit as Vt, PROMPT_TEXT_MAX as W, toModelInfo as Wt, REVIEW_GATE_STATUS_VALUES as X, actorColorIndex as Xt, RESPONSES_API_TOOL_MODELS as Y, ACTOR_COLOR_SLOTS as Yt, SUBQUEST_STATUS_VALUES as Z, actorKindMarker as Zt, BadRequestError as _, isAudioMimeType as _t, getCreditsUrl as a, VideoModels as at, CREDIT_DEDUCT_TRANSACTION_TYPES as b, isEarlyStop as bt, requireApiUrl as c, applyModelPriceCatalog as ct, AGENT_QUEST_MANIFEST as d, defaultEmbeddingModelForEnv as dt, buildRateLimitLogEntry as en, TTS_MAX_INPUT_CHARS as et, AGENT_QUEST_MCP_URI as f, getMcpProviderMetadata as ft, BFL_SAFETY_TOLERANCE as g, hasUsableLimits as gt, BEDROCK_NO_PROMPT_CACHING_MODELS as h, hasKeylessCloudEmbedder as ht, LOCAL_DEV_URL as i, VIDEO_SIZE_CONSTRAINTS as it, HttpStatus as j, isRenderableModelType as jt, ForbiddenError as k, isModelDeprecated as kt, resolveApiEndpoint as l, calculateRetryDelay as lt, ApiKeyType as m, getRetryAfterMs as mt, logger as n, isNearLimit as nn, UnauthorizedError as nt, getEnvironmentName as o, VoyageAIEmbeddingModel as ot, ARTIFACT_ATTRS_PATTERN as p, getQuestErrorCode as pt, REASONING_SUPPORTED_MODELS as q, usdToCreditsStochastic as qt, ApiEndpointUnconfiguredError as r, parseRateLimitHeaders as rn, UnprocessableEntityError as rt, parseApiUrl as s, WORK_ITEM_STATUSES as st, ConfigStore as t, extractSnippetMeta as tn, TooManyRequestsError as tt, AGENT_QUEST_ID as u, dayjsConfig_default as ut, BedrockEmbeddingModel as v, isChunkRebuildPending as vt, DEFAULT_UNKNOWN_CONTEXT_WINDOW as w, isGeminiModelId as wt, ChatModels as x, isFieldGroup as xt, CONTEXT_WINDOW_SAFETY_BUFFER_TOKENS as y, isChunkStalledFile as yt, NotFoundError as z, parseEmbeddingRateLimitHeaders as zt };