@bike4mind/cli 1.2.0 → 2.1.0

package/dist/{AgentHistoryStore-B2NEOvSW.mjs → AgentHistoryStore-DdYKfx7C.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as withRetry, A as NotFoundError, B as WORK_ITEM_STATUSES, E as LOCATION_MAP_LANGUAGE, G as googleMapsSearchUrl, I as SEARCH_RESULT_CARDS_LANGUAGE, J as isRetryableError, M as OpenAIEmbeddingModel, O as McpServerName, P as PermissionDeniedError, Q as signImageUrl, R as SupportedFabFileMimeTypes, U as getMcpProviderMetadata, X as obfuscateApiKey, Z as secureParameters, a as canTrustTool, b as ApiKeyType, c as SESSION_ID_PATTERN, i as loadContextFiles, j as OllamaEmbeddingModel, l as isValidSessionId, n as logger, o as getToolCategory, q as isPlaceholderImageSigningSecret, s as isReadOnlyTool, w as ChatModels, x as BedrockEmbeddingModel, z as VoyageAIEmbeddingModel } from "./ConfigStore-qV7NrCgZ.mjs";
+import { A as ChatModels, B as NotFoundError, E as BedrockEmbeddingModel, H as OpenAIEmbeddingModel, I as LOCATION_MAP_LANGUAGE, J as SupportedFabFileMimeTypes, K as SEARCH_RESULT_CARDS_LANGUAGE, Mt as APP_NAME, Nt as WEBSITE_URL, R as McpServerName, V as OllamaEmbeddingModel, W as PermissionDeniedError, X as WORK_ITEM_STATUSES, Y as VoyageAIEmbeddingModel, a as htmlErrorTitle, c as loadContextFiles, ct as isRetryableError, d as isReadOnlyTool, dt as obfuscateApiKey, gt as splitEquals, ht as signImageUrl, i as isValidSessionId, it as googleMapsSearchUrl, l as canTrustTool, mt as secureParameters, n as logger, nt as getMcpProviderMetadata, o as htmlFirstH1, r as SESSION_ID_PATTERN, st as isPlaceholderImageSigningSecret, u as getToolCategory, w as ApiKeyType, wt as withRetry } from "./ConfigStore-BygzEI6H.mjs";
 import { n as isPathAllowed, t as assertPathAllowed } from "./pathValidation-BRqf4HFX-CHwtwp3O.mjs";
 import { n as isTerminalShellStatus, t as getShellSessionManager } from "./ShellSessionManager-6o8KZzl1-vrbPAUTq.mjs";
 import { execFile, execFileSync, spawn } from "child_process";
@@ -864,7 +864,7 @@ const getSerperKey = async (adapters) => {
 };
 const getSearxngUrl = async (adapters) => {
 	const { db } = adapters;
-	return (await db.adminSettings.findBySettingName("SearxngUrl"))?.settingValue?.trim() || envKey("SEARXNG_BASE_URL");
+	return (await db.adminSettings.findBySettingName("SearxngUrl"))?.settingValue?.trim() || process.env.SEARXNG_BASE_URL?.trim() || null;
 };
 const getWebSearchProviderSetting = async (adapters) => {
 	const { db } = adapters;
@@ -982,7 +982,10 @@ const setApiKey = async (userId, parameters, { db }) => {
 	if (!apiKey) throw new NotFoundError("API key not found");
 	await db.apiKeys.updateAllByUserIdAndType(userId, type, { isActive: false });
 	apiKey.isActive = true;
-	await db.apiKeys.update(apiKey);
+	await db.apiKeys.update({
+		id: apiKey.id,
+		isActive: true
+	});
 	return apiKey;
 };
 const listOwnApiKeys = async (userId, adapters, options = {}) => {
@@ -1629,6 +1632,7 @@ new https.Agent({
 	lookup: ssrfSafeLookup,
 	keepAlive: false
 });
+`${APP_NAME || "App"}`, WEBSITE_URL && `${WEBSITE_URL}`;
 `${"a, span, em, strong, b, i, u, code, kbd, samp, var, sub, sup, small, abbr, cite, q, time, mark, s, del, ins, bdi, bdo, wbr, ruby, rt, rp".split(", ").join("):not(")}`;
 [
 	"[aria-hidden=\"true\"]",
@@ -2206,7 +2210,96 @@ const webFetchTool = {
 	})
 };
 //#endregion
-//#region ../../b4m-core/services/dist/websearch-CChnLwlz.mjs
+//#region ../../b4m-core/services/dist/prompts-Df-9fQuz.mjs
+/**
+* Teaches the `b4m_cards` fence, appended to a web_search result ONLY when that search actually
+* returned images (see shouldIncludeImages). Delivering it with the results rather than in the system
+* prompt costs nothing on the turns that will never use it, and arrives exactly when it is actionable.
+*
+* The field names must stay in sync with the parser in
+* apps/client/app/components/Session/parseSearchResultCards.ts; the fence language is shared.
+*/
+const WEB_SEARCH_CARDS_PROMPT = [
+	"The results above include images, so illustrate your answer - do not wait to be asked. When you name specific",
+	`things the user would want to SEE, emit a \`\`\`${SEARCH_RESULT_CARDS_LANGUAGE} fenced block inline in your reply, placed`,
+	"exactly where the pictures belong - right after the sentence that introduces them, not at the end.",
+	"The block is a single JSON object:",
+	"",
+	`\`\`\`${SEARCH_RESULT_CARDS_LANGUAGE}`,
+	"{\"cards\":[{\"name\":\"Orient Bambino\",\"note\":\"Your own description of this thing, in your voice.\",",
+	"\"meta\":\"~$200\",\"url\":\"https://orientwatch.co/bambino\",\"images\":[",
+	"{\"url\":\"https://example.com/a.jpg\",\"source\":\"orientwatch.co\"},",
+	"{\"url\":\"https://example.com/b.jpg\",\"source\":\"jomashop\"}]}]}",
+	"```",
+	"",
+	"Rules: `name` and at least one `images` entry are required. Every image `url` must be copied verbatim",
+	"from an `image:` or Images line above, never invented or guessed, and `source` is that entry's own",
+	"`source`/hostname, so each picture is attributed. Prefer the \"Images found for this search\" pool:",
+	"those carry their own page and publisher. `note` is YOUR prose about the thing, not the",
+	"search snippet. `meta` is a short footer such as a price or key spec. `url` is where the card links.",
+	"Two to six cards is the useful range. Keep writing normally around the block - it replaces neither",
+	"your explanation nor your citations. Omit the block only if the results genuinely have no images",
+	"worth showing; never tell the user you could show pictures if they asked - just show them."
+].join("\n");
+/**
+* Teaches the `b4m_map` fence, appended to a web_search result ONLY when that search returned places
+* with provider coordinates (see shouldIncludePlaces). The fence names places by id alone, so the
+* model never writes a coordinate - the client resolves each id against the stored place citables.
+*
+* The field names must stay in sync with parseLocationMapFence in
+* b4m-core/common/src/constants/locationMap.ts.
+*/
+const WEB_SEARCH_MAP_PROMPT = [
+	"The results above include places with map locations, so show them on a map - do not wait to be asked.",
+	`Emit one \`\`\`${LOCATION_MAP_LANGUAGE} fenced block inline in your reply, placed where the map belongs - right`,
+	"after the sentence that introduces the places. The block is a single JSON object:",
+	"",
+	`\`\`\`${LOCATION_MAP_LANGUAGE}`,
+	"{\"anchor\":{\"id\":\"<anchor id>\",\"name\":\"citizenM Copenhagen\",\"label\":\"Your hotel\"},",
+	"\"places\":[{\"id\":\"<place id>\",\"name\":\"Barr\",\"note\":\"Your own one-line take on this place.\"}]}",
+	"```",
+	"",
+	"Rules: every `id` must be copied verbatim from an `id:` line above - never invent one, and never write",
+	"coordinates; the map locates each place from its id. `name` is the place name as listed. `note` is",
+	"YOUR short line about why it fits the request. Include `anchor` only when an \"Anchor location\" is listed",
+	"above, with a short `label` for what it is to the user (\"Your hotel\", \"Your office\"). List the places",
+	"worth recommending, three to ten. Keep writing normally around the block - it does not replace your",
+	"explanation or citations. Omit it only if none of the places actually answer the question."
+].join("\n");
+//#endregion
+//#region ../../b4m-core/services/dist/websearch-BpzP6-Zz.mjs
+/**
+* Per-process cache for web-search results. Keyed on normalized query + result count, with a
+* short TTL so repeated/similar searches within a turn or across back-to-back turns reuse the
+* same provider response. The cache lives in the Fargate container's memory and is never shared
+* across containers or persisted.
+*/
+const SEARCH_CACHE_TTL_MS = 3e5;
+const SEARCH_CACHE_MAX_ENTRIES = 200;
+const searchCache = /* @__PURE__ */ new Map();
+function searchCacheKey(query, numResults, placeSearch) {
+	return `${query.trim().toLowerCase()}::${numResults}${placeSearch ? "::places" : ""}`;
+}
+function searchCacheGet(query, numResults, placeSearch) {
+	const key = searchCacheKey(query, numResults, placeSearch);
+	const entry = searchCache.get(key);
+	if (!entry) return void 0;
+	if (Date.now() > entry.expiresAt) {
+		searchCache.delete(key);
+		return;
+	}
+	return entry.results;
+}
+function searchCacheSet(query, numResults, results, placeSearch) {
+	if (searchCache.size >= SEARCH_CACHE_MAX_ENTRIES) {
+		const firstKey = searchCache.keys().next().value;
+		if (firstKey !== void 0) searchCache.delete(firstKey);
+	}
+	searchCache.set(searchCacheKey(query, numResults, placeSearch), {
+		results,
+		expiresAt: Date.now() + SEARCH_CACHE_TTL_MS
+	});
+}
 /**
 * The coarse recency bucket both providers speak, as the smallest one containing `recencyDays`.
 * Null when there is no constraint, or when the window is wider than the widest bucket - a
@@ -2228,10 +2321,19 @@ const SERPAPI_QDR = {
 	year: "qdr:y"
 };
 const DEFAULT_NUM_RESULTS = 3;
-const SEARCH_TIMEOUT_MS = 6e4;
-const SERPAPI_ATTEMPT_TIMEOUT_MS = 2e4;
+const SEARCH_TIMEOUT_MS = 1e4;
+const SERPAPI_ATTEMPT_TIMEOUT_MS = 1e4;
 const SERPAPI_MAX_ATTEMPTS = 2;
 const SERPAPI_RETRY_DELAY_MS = 500;
+/**
+* How long the lead provider gets before the backup is started alongside it (sooner if the lead
+* fails or comes back empty first). Just past SerpAPI's normal response time in production: answers come back in about
+* 1s typically and 3s at the 90th percentile, while a stalled request usually never answers.
+*/
+const WEB_SEARCH_HEDGE_DELAY_MS = 3e3;
+const SERPAPI_ORGANIC_MS = 20500;
+const HEDGED_BACKUP_MS = WEB_SEARCH_HEDGE_DELAY_MS + Math.max(SEARCH_TIMEOUT_MS, 1 * SERPAPI_ATTEMPT_TIMEOUT_MS);
+Math.max(SERPAPI_ORGANIC_MS, HEDGED_BACKUP_MS) + SEARCH_TIMEOUT_MS;
 const MAX_IMAGES_PER_RESULT = 4;
 const DEFAULT_IMAGE_RESULTS = 12;
 const DEFAULT_PLACE_RESULTS = 10;
@@ -2319,6 +2421,11 @@ function indexImagesByLink(inlineImages, shoppingResults) {
 function isAbortError$1(error) {
 	return typeof error === "object" && error !== null && error.name === "AbortError";
 }
+function setSerpApiGeoTargeting(searchParams, options) {
+	if (options?.locationInQuery) return;
+	searchParams.set("location", "United States");
+	searchParams.set("gl", "us");
+}
 const sleep$1 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
 * One SerpAPI organic-search attempt, bounded by SERPAPI_ATTEMPT_TIMEOUT_MS. Never throws -
@@ -2413,21 +2520,21 @@ async function serpApiSearch(adapters, query, num_results, options) {
 		engine: "google",
 		api_key: apiKey,
 		q: query,
-		location: "United States",
 		google_domain: "google.com",
-		gl: "us",
 		hl: "en",
 		num: (num_results || DEFAULT_NUM_RESULTS).toString()
 	});
+	setSerpApiGeoTargeting(searchParams, options);
 	const bucket = recencyBucket(options?.recencyDays);
 	if (bucket) searchParams.set("tbs", SERPAPI_QDR[bucket]);
 	url.search = searchParams.toString();
+	const maxAttempts = Math.min(Math.max(1, options?.maxAttempts ?? SERPAPI_MAX_ATTEMPTS), SERPAPI_MAX_ATTEMPTS);
 	const failures = [];
-	for (let attempt = 1; attempt <= SERPAPI_MAX_ATTEMPTS; attempt++) {
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
 		const outcome = await attemptSerpApiRequest(url, attempt);
 		if (outcome.ok) return outcome.data;
 		failures.push(outcome);
-		if (!outcome.retryable || attempt === SERPAPI_MAX_ATTEMPTS) break;
+		if (!outcome.retryable || attempt === maxAttempts) break;
 		Logger.globalInstance.log("📡 WebSearch Tool: retrying SerpAPI after transient failure", {
 			attempt,
 			status: outcome.status,
@@ -2442,20 +2549,20 @@ async function serpApiSearch(adapters, query, num_results, options) {
 * `include_images` on a visual query. Failures resolve to [] - missing pictures degrade the reply
 * to prose, they never fail the search.
 */
-async function serpApiImageSearch(adapters, query, limit) {
+async function serpApiImageSearch(adapters, query, limit, options) {
 	const apiKey = await (0, apiKeyService_exports.getSerperKey)(adapters);
 	if (!apiKey) return [];
 	const url = new URL("https://serpapi.com/search");
-	url.search = new URLSearchParams({
+	const searchParams = new URLSearchParams({
 		engine: "google_images",
 		api_key: apiKey,
 		q: query,
-		location: "United States",
 		google_domain: "google.com",
-		gl: "us",
 		hl: "en",
 		safe: "active"
-	}).toString();
+	});
+	setSerpApiGeoTargeting(searchParams, options);
+	url.search = searchParams.toString();
 	const controller = new AbortController();
 	const timeoutId = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
 	try {
@@ -2555,7 +2662,7 @@ function safeHost(url) {
 function createSerpApiProvider(adapters) {
 	return {
 		name: "serpapi",
-		searchImages: (query, limit) => serpApiImageSearch(adapters, query, limit ?? DEFAULT_IMAGE_RESULTS),
+		searchImages: (query, limit, options) => serpApiImageSearch(adapters, query, limit ?? DEFAULT_IMAGE_RESULTS, options),
 		searchPlaces: (query, limit) => serpApiPlaceSearch(adapters, query, limit ?? DEFAULT_PLACE_RESULTS),
 		async search(query, numResults, options) {
 			const data = await serpApiSearch(adapters, query, numResults, options);
@@ -2696,90 +2803,48 @@ function createSearxngProvider(baseUrl) {
 						status: response.status,
 						statusText: response.statusText
 					});
+					if (options?.throwOnError) throw new Error(`SearXNG error: HTTP ${response.status}`);
 					return [];
 				}
 				return parseSearxngResults(await response.json(), limit);
 			} catch (error) {
 				Logger.globalInstance.error("❌ WebSearch Tool: SearXNG request failed:", error);
-				return [];
+				if (!options?.throwOnError) return [];
+				if (isAbortError$1(error)) throw new Error(`Web search timed out: SearXNG did not respond within ${SEARCH_TIMEOUT_MS / 1e3}s`);
+				throw error;
 			} finally {
 				clearTimeout(timeoutId);
 			}
 		}
 	};
 }
-/**
-* Resolve the active web-search provider, or null when none is configured. Precedence:
-*   - explicit admin choice ('serpapi' | 'searxng') forces that provider (null if it's unconfigured)
-*   - 'auto' (default): SearXNG if a URL is configured (admin setting or SEARXNG_BASE_URL env),
-*     else SerpAPI if a Serper key is set, else null.
-* Mirrored by computeToolAvailability in serverConfig.ts so the picker's gating matches the tool.
-*/
-async function resolveWebSearchProvider(adapters) {
-	const choice = await (0, apiKeyService_exports.getWebSearchProviderSetting)(adapters) ?? "auto";
-	const searxngUrl = await (0, apiKeyService_exports.getSearxngUrl)(adapters);
-	const serperKey = await (0, apiKeyService_exports.getSerperKey)(adapters);
+async function readProviderSettings(adapters) {
+	return {
+		choice: await (0, apiKeyService_exports.getWebSearchProviderSetting)(adapters) ?? "auto",
+		searxngUrl: await (0, apiKeyService_exports.getSearxngUrl)(adapters),
+		serperKey: await (0, apiKeyService_exports.getSerperKey)(adapters)
+	};
+}
+function pickPrimaryProvider(adapters, { choice, searxngUrl, serperKey }) {
 	if (choice === "searxng") return searxngUrl ? createSearxngProvider(searxngUrl) : null;
 	if (choice === "serpapi") return serperKey ? createSerpApiProvider(adapters) : null;
-	if (searxngUrl) return createSearxngProvider(searxngUrl);
 	if (serperKey) return createSerpApiProvider(adapters);
+	if (searxngUrl) return createSearxngProvider(searxngUrl);
 	return null;
 }
 /**
-* Teaches the `b4m_cards` fence, appended to a web_search result ONLY when that search actually
-* returned images (see shouldIncludeImages). Delivering it with the results rather than in the system
-* prompt costs nothing on the turns that will never use it, and arrives exactly when it is actionable.
-*
-* The field names must stay in sync with the parser in
-* apps/client/app/components/Session/parseSearchResultCards.ts; the fence language is shared.
+* Returns [lead, backup] for searchWithHedge. The lead is exactly what
+* resolveWebSearchProvider picks: the admin's WebSearchProvider choice, or under 'auto' SerpAPI
+* when a key is set, else SearXNG. The backup is the other provider when it is configured too. An
+* unconfigured explicit choice yields no lead at all; it is never quietly replaced by the other.
 */
-const WEB_SEARCH_CARDS_PROMPT = [
-	"The results above include images, so illustrate your answer - do not wait to be asked. When you name specific",
-	`things the user would want to SEE, emit a \`\`\`${SEARCH_RESULT_CARDS_LANGUAGE} fenced block inline in your reply, placed`,
-	"exactly where the pictures belong - right after the sentence that introduces them, not at the end.",
-	"The block is a single JSON object:",
-	"",
-	`\`\`\`${SEARCH_RESULT_CARDS_LANGUAGE}`,
-	"{\"cards\":[{\"name\":\"Orient Bambino\",\"note\":\"Your own description of this thing, in your voice.\",",
-	"\"meta\":\"~$200\",\"url\":\"https://orientwatch.co/bambino\",\"images\":[",
-	"{\"url\":\"https://example.com/a.jpg\",\"source\":\"orientwatch.co\"},",
-	"{\"url\":\"https://example.com/b.jpg\",\"source\":\"jomashop\"}]}]}",
-	"```",
-	"",
-	"Rules: `name` and at least one `images` entry are required. Every image `url` must be copied verbatim",
-	"from an `image:` or Images line above, never invented or guessed, and `source` is that entry's own",
-	"`source`/hostname, so each picture is attributed. Prefer the \"Images found for this search\" pool:",
-	"those carry their own page and publisher. `note` is YOUR prose about the thing, not the",
-	"search snippet. `meta` is a short footer such as a price or key spec. `url` is where the card links.",
-	"Two to six cards is the useful range. Keep writing normally around the block - it replaces neither",
-	"your explanation nor your citations. Omit the block only if the results genuinely have no images",
-	"worth showing; never tell the user you could show pictures if they asked - just show them."
-].join("\n");
-/**
-* Teaches the `b4m_map` fence, appended to a web_search result ONLY when that search returned places
-* with provider coordinates (see shouldIncludePlaces). The fence names places by id alone, so the
-* model never writes a coordinate - the client resolves each id against the stored place citables.
-*
-* The field names must stay in sync with parseLocationMapFence in
-* b4m-core/common/src/constants/locationMap.ts.
-*/
-const WEB_SEARCH_MAP_PROMPT = [
-	"The results above include places with map locations, so show them on a map - do not wait to be asked.",
-	`Emit one \`\`\`${LOCATION_MAP_LANGUAGE} fenced block inline in your reply, placed where the map belongs - right`,
-	"after the sentence that introduces the places. The block is a single JSON object:",
-	"",
-	`\`\`\`${LOCATION_MAP_LANGUAGE}`,
-	"{\"anchor\":{\"id\":\"<anchor id>\",\"name\":\"citizenM Copenhagen\",\"label\":\"Your hotel\"},",
-	"\"places\":[{\"id\":\"<place id>\",\"name\":\"Barr\",\"note\":\"Your own one-line take on this place.\"}]}",
-	"```",
-	"",
-	"Rules: every `id` must be copied verbatim from an `id:` line above - never invent one, and never write",
-	"coordinates; the map locates each place from its id. `name` is the place name as listed. `note` is",
-	"YOUR short line about why it fits the request. Include `anchor` only when an \"Anchor location\" is listed",
-	"above, with a short `label` for what it is to the user (\"Your hotel\", \"Your office\"). List the places",
-	"worth recommending, three to ten. Keep writing normally around the block - it does not replace your",
-	"explanation or citations. Omit it only if none of the places actually answer the question."
-].join("\n");
+async function resolveWebSearchProviders(adapters) {
+	const settings = await readProviderSettings(adapters);
+	const lead = pickPrimaryProvider(adapters, settings);
+	if (!lead) return [null, null];
+	if (lead.name === "serpapi") return [lead, settings.searxngUrl ? createSearxngProvider(settings.searxngUrl) : null];
+	return [lead, settings.serperKey ? createSerpApiProvider(adapters) : null];
+}
 function safeHostname(url) {
 	try {
 		return new URL(url).hostname;
@@ -2864,9 +2929,73 @@ function placeCitable(place, imageUrlSigningSecret, canSignImages) {
 	};
 }
 const WEB_SEARCH_NOT_CONFIGURED_MSG = "Web search is not configured: an administrator needs to set a Serper API key or a local SearXNG URL in Admin > API Keys. No search was performed.";
-async function performWebSearch(adapters, params, imageUrlSigningSecret = "") {
+var EmptySearchAnswer = class extends Error {};
+const errorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
+/**
+* Organic search as a hedged request: the lead starts at once, and the backup starts alongside it
+* once the lead has been silent for WEB_SEARCH_HEDGE_DELAY_MS, or as soon as the lead fails. The
+* first non-empty answer wins; the loser runs on to its own timeout and is ignored. An empty lead
+* answer also starts the backup, since a throttled SearXNG answers 200 with no results. With no
+* backup the lead keeps its own failure mode (SearXNG fail-soft, SerpAPI throws). Returns the
+* provider that answered so follow-up calls (images, places) go to a live provider. With a backup,
+* results are empty when neither provider has any (both empty, or one empty and the other failed),
+* and it throws only when both failed.
+*/
+async function searchWithHedge(lead, backup, query, numResults, searchOptions) {
+	if (!backup) return {
+		results: await lead.search(query, numResults, searchOptions),
+		servedBy: lead
+	};
+	const fromLead = lead.search(query, numResults, {
+		...searchOptions,
+		throwOnError: true
+	});
+	const fromBackup = new Promise((start) => {
+		const timer = setTimeout(() => start("slow"), WEB_SEARCH_HEDGE_DELAY_MS);
+		fromLead.then((results) => {
+			clearTimeout(timer);
+			if (results.length === 0) start("empty");
+		}, () => {
+			clearTimeout(timer);
+			start("failed");
+		});
+	}).then((reason) => {
+		Logger.globalInstance.log("WebSearch Tool: starting backup provider", {
+			lead: lead.name,
+			backup: backup.name,
+			reason
+		});
+		return backup.search(query, numResults, {
+			...searchOptions,
+			throwOnError: true,
+			maxAttempts: 1
+		});
+	});
+	const nonEmpty = (answer, provider) => answer.then((results) => {
+		if (results.length === 0) throw new EmptySearchAnswer();
+		return {
+			results,
+			servedBy: provider
+		};
+	});
+	try {
+		return await Promise.any([nonEmpty(fromLead, lead), nonEmpty(fromBackup, backup)]);
+	} catch (error) {
+		const [leadError, backupError] = error instanceof AggregateError ? error.errors : [error, error];
+		if (leadError instanceof EmptySearchAnswer) return {
+			results: [],
+			servedBy: lead
+		};
+		if (backupError instanceof EmptySearchAnswer) return {
+			results: [],
+			servedBy: backup
+		};
+		throw new Error(`Web search failed on both providers. ${lead.name}: ${errorMessage$1(leadError)}; ${backup.name}: ${errorMessage$1(backupError)}`);
+	}
+}
+async function performWebSearch(adapters, params, imageUrlSigningSecret = "", resolvedProviders) {
 	Logger.globalInstance.log("🔍 WebSearch Tool: Starting search for query:", params.query);
-	const provider = await resolveWebSearchProvider(adapters);
+	const [provider, backup] = await (resolvedProviders ?? resolveWebSearchProviders(adapters));
 	if (!provider) {
 		Logger.globalInstance.error("❌ WebSearch Tool: No web-search provider configured. Skipping search.");
 		return {
@@ -2875,21 +3004,33 @@ async function performWebSearch(adapters, params, imageUrlSigningSecret = "") {
 		};
 	}
 	try {
-		const results = await provider.search(params.query, params.num_results);
-		Logger.globalInstance.log(`📊 WebSearch Tool: ${provider.name} found ${results.length} results`);
+		const searchOptions = params.include_places ? { locationInQuery: true } : void 0;
+		const numResults = params.num_results ?? 3;
+		const isPlaceSearch = !!params.include_places;
+		const cached = searchCacheGet(params.query, numResults, isPlaceSearch);
+		let results;
+		let servedBy = provider;
+		if (cached) {
+			Logger.globalInstance.log("WebSearch Tool: cache hit", { query: params.query });
+			results = cached;
+		} else {
+			({results, servedBy} = await searchWithHedge(provider, backup, params.query, numResults, searchOptions));
+			if (results.length > 0) searchCacheSet(params.query, numResults, results, isPlaceSearch);
+		}
+		Logger.globalInstance.log(`📊 WebSearch Tool: ${servedBy.name} found ${results.length} results${cached ? " (cached)" : ""}`);
 		const canSignImages = !isPlaceholderImageSigningSecret(imageUrlSigningSecret);
 		const wantsImages = !!params.include_images && canSignImages;
 		const anchorQuery = params.include_places ? params.anchor_location?.trim() : void 0;
 		const [imageResults, placeResults, anchorResults] = await Promise.all([
-			wantsImages ? provider.searchImages?.(params.query) : void 0,
-			params.include_places ? provider.searchPlaces?.(params.query) : void 0,
-			anchorQuery ? provider.searchPlaces?.(anchorQuery, 1) : void 0
+			wantsImages ? servedBy.searchImages?.(params.query, void 0, searchOptions) : void 0,
+			params.include_places ? servedBy.searchPlaces?.(params.query) : void 0,
+			anchorQuery ? servedBy.searchPlaces?.(anchorQuery, 1) : void 0
 		]).then((all) => all.map((result) => result ?? []));
 		const anchor = anchorResults[0];
 		const places = placeResults.filter((place) => place.id !== anchor?.id);
 		const withPlaces = shouldIncludePlaces(places, params.include_places);
-		if (placeResults.length) Logger.globalInstance.log(`WebSearch Tool: ${provider.name} found ${placeResults.length} places`);
-		if (imageResults.length) Logger.globalInstance.log(`🖼️ WebSearch Tool: ${provider.name} found ${imageResults.length} images`);
+		if (placeResults.length) Logger.globalInstance.log(`WebSearch Tool: ${servedBy.name} found ${placeResults.length} places`);
+		if (imageResults.length) Logger.globalInstance.log(`🖼️ WebSearch Tool: ${servedBy.name} found ${imageResults.length} images`);
 		const withImages = shouldIncludeImages(results, wantsImages, imageResults);
 		const citables = results.map((result, index) => ({
 			id: result.url,
@@ -2927,50 +3068,66 @@ async function performWebSearch(adapters, params, imageUrlSigningSecret = "") {
 }
 const webSearchTool = {
 	name: "web_search",
-	implementation: (context, toolConfig) => ({
-		toolFn: async (value) => {
-			const params = value;
-			await context.onStart?.("web_search", params);
-			const { formattedResults, citables } = await performWebSearch({ db: context.db }, params, toolConfig?.imageUrlSigningSecret);
-			if (citables.length > 0) {
-				await context.statusUpdate({ promptMeta: { citables } }, "Web search complete");
-				Logger.globalInstance.log(`📚 WebSearch Tool: Stored ${citables.length} citables`);
-			}
-			return formattedResults;
-		},
-		toolSchema: {
-			name: "web_search",
-			description: "Search the web using Google Search API to FIND pages about a topic. Use this when you need to find URLs or search for information. DO NOT use this if the user provides a specific URL - use web_fetch instead to read the full content.",
-			parameters: {
-				type: "object",
-				properties: {
-					query: {
-						type: "string",
-						description: "The search query to look up"
-					},
-					num_results: {
-						type: "number",
-						description: "Number of results to return (default: 3, max: 10)",
-						minimum: 1,
-						maximum: 10
-					},
-					include_images: {
-						type: "boolean",
-						description: "Set true whenever the answer is about things worth SEEING - products, watches, gear, places, buildings, plants, animals, people, cars, art, food, anything with a look. Decide this yourself from the subject matter: the user will NOT ask for pictures, and an answer that describes a physical object without showing it is a worse answer. Adds a set of attributed images so you can illustrate your reply with a b4m_cards block. Leave unset only for genuinely non-visual questions - code, math, definitions, policy - where images would be junk tokens."
-					},
-					include_places: {
-						type: "boolean",
-						description: "Set true when the answer is a set of PLACES the user would want to see on a map - restaurants, bars, cafes, shops, hotels, attractions, things to do in or near somewhere. Decide this yourself: the user will not ask for a map. Adds places with map locations so you can show them with a b4m_map block. Leave unset for anything that is not about physical locations."
+	implementation: (context, config) => {
+		let searchCallCount = 0;
+		let providersPromise;
+		return {
+			toolFn: async (value) => {
+				const params = value;
+				const callNumber = ++searchCallCount;
+				await context.onStart?.("web_search", params);
+				providersPromise ??= resolveWebSearchProviders({ db: context.db }).catch((error) => {
+					providersPromise = void 0;
+					throw error;
+				});
+				const startedAt = Date.now();
+				const { formattedResults, citables } = await performWebSearch({ db: context.db }, params, config?.imageUrlSigningSecret, providersPromise);
+				context.logger.log("🔍 WebSearch Tool: search timing", {
+					callNumber,
+					query: params.query,
+					durationMs: Date.now() - startedAt,
+					resultCount: citables.length
+				});
+				if (citables.length > 0) {
+					await context.statusUpdate({ promptMeta: { citables } }, "Web search complete");
+					Logger.globalInstance.log(`📚 WebSearch Tool: Stored ${citables.length} citables`);
+				}
+				return formattedResults;
+			},
+			toolSchema: {
+				name: "web_search",
+				description: "Search the web using Google Search API to FIND pages about a topic. Use this when you need to find URLs or search for information. DO NOT use this if the user provides a specific URL - use web_fetch instead to read the full content.",
+				parameters: {
+					type: "object",
+					properties: {
+						query: {
+							type: "string",
+							description: "The search query to look up"
+						},
+						num_results: {
+							type: "number",
+							description: "Number of results to return (default: 3, max: 10)",
+							minimum: 1,
+							maximum: 10
+						},
+						include_images: {
+							type: "boolean",
+							description: "Set true whenever the answer is about things worth SEEING - products, watches, gear, places, buildings, plants, animals, people, cars, art, food, anything with a look. Decide this yourself from the subject matter: the user will NOT ask for pictures, and an answer that describes a physical object without showing it is a worse answer. Adds a set of attributed images so you can illustrate your reply with a b4m_cards block. Leave unset only for genuinely non-visual questions - code, math, definitions, policy - where images would be junk tokens."
+						},
+						include_places: {
+							type: "boolean",
+							description: "Set true when the answer is a set of PLACES the user would want to see on a map - restaurants, bars, cafes, shops, hotels, attractions, things to do in or near somewhere. Decide this yourself: the user will not ask for a map. Adds places with map locations so you can show them with a b4m_map block. Leave unset for anything that is not about physical locations."
+						},
+						anchor_location: {
+							type: "string",
+							description: "With include_places: the reference place the user named that results should be near, as a searchable name with its city, e.g. \"citizenM Copenhagen Radhuspladsen\". Shown distinctly on the map. Omit when the user named none."
+						}
 					},
-					anchor_location: {
-						type: "string",
-						description: "With include_places: the reference place the user named that results should be near, as a searchable name with its city, e.g. \"citizenM Copenhagen Radhuspladsen\". Shown distinctly on the map. Omit when the user named none."
-					}
-				},
-				required: ["query"]
+					required: ["query"]
+				}
 			}
-		}
-	})
+		};
+	}
 };
 //#endregion
 //#region ../../b4m-core/services/dist/weather-jxxOpyX5.mjs
@@ -3086,81 +3243,32 @@ function normalizeId(value) {
 	return typeof value === "number" && Number.isFinite(value) ? String(value) : void 0;
 }
 //#endregion
-//#region ../../b4m-core/services/dist/latticeModelService-9biwOOa0.mjs
-const WHITESPACE$1 = /\s/;
-const EQUALS_OPS = [
-	"=",
-	"equals",
-	"equal"
-];
-function isLineTerminator(s, i) {
-	const c = s.charCodeAt(i);
-	return c === 10 || c === 13 || c === 8232 || c === 8233;
-}
-function indexText(s) {
-	const n = s.length;
-	const wsEnd = new Int32Array(n + 1);
-	const lineEnd = new Int32Array(n + 1);
-	wsEnd[n] = n;
-	lineEnd[n] = n;
-	let lastLineTerminator = -1;
-	for (let i = n - 1; i >= 0; i--) {
-		wsEnd[i] = WHITESPACE$1.test(s[i]) ? wsEnd[i + 1] : i;
-		const lt = isLineTerminator(s, i);
-		lineEnd[i] = lt ? i : lineEnd[i + 1];
-		if (lt && lastLineTerminator < 0) lastLineTerminator = i;
-	}
-	return {
-		s,
-		n,
-		wsEnd,
-		lineEnd,
-		lastLineTerminator
-	};
-}
-/** Case-insensitive match of a lowercase ASCII `word` at i, as the `i` flag compares ASCII letters. */
-function wordAt(s, i, word) {
-	if (i + word.length > s.length) return false;
-	for (let j = 0; j < word.length; j++) {
-		let c = s.charCodeAt(i + j);
-		if (c >= 65 && c <= 90) c += 32;
-		if (c !== word.charCodeAt(j)) return false;
-	}
-	return true;
-}
-/** `/^(.+?)\s*(?:=|equals?)\s*(.+)$/i` -> [output, expression]. */
-function splitEquals(s) {
-	const ix = indexText(s);
-	const limit = Math.min(ix.lineEnd[0], ix.n - 1);
-	let lastK = -1;
-	for (let g = 1; g <= limit; g++) {
-		const k = ix.wsEnd[g];
-		if (k === lastK) continue;
-		lastK = k;
-		for (const op of EQUALS_OPS) {
-			if (!wordAt(s, k, op)) continue;
-			const p = k + op.length;
-			const w = ix.wsEnd[p];
-			let rest = -1;
-			if (w < ix.n) rest = ix.lastLineTerminator < w ? w : -1;
-			else if (ix.n - 1 >= p && !isLineTerminator(s, ix.n - 1)) rest = ix.n - 1;
-			if (rest >= 0) return [s.slice(0, g), s.slice(rest)];
-		}
-	}
-	return null;
-}
+//#region ../../b4m-core/services/dist/latticeModelService-DTKpo_hV.mjs
 /**
 * The model's creator, compared through `normalizeId` on both sides.
 *
-* This is the WRITE gate (via `getModelForWrite`) and the owner arm of the read gate, and the
-* subagent Lattice tools in `llm/tools/implementation/lattice` import it so the two surfaces
-* cannot drift apart again.
+* This is the WRITE gate (via `getModelForWrite`) and the owner arm of the read gate.
 */
 function isModelOwner(model, user) {
 	const ownerId = normalizeId(model.userId);
 	return ownerId !== void 0 && ownerId === normalizeId(user.id);
 }
 /**
+* READ gate: the creator, or a member of the organization the model was created in.
+*
+* Both org ids go through `normalizeId` because they are NOT the same runtime type:
+* `LatticeModel.organizationId` is a String schema path while `req.user.organizationId` is an
+* ObjectId on the hydrated user document, so a raw `===` was always false and silently collapsed
+* org sharing to owner-only everywhere.
+*
+* Write authority stays narrower on purpose - see `getModelForWrite`.
+*/
+function canReadModel(model, user) {
+	if (isModelOwner(model, user)) return true;
+	const modelOrgId = normalizeId(model.organizationId);
+	return modelOrgId !== void 0 && modelOrgId === normalizeId(user.organizationId);
+}
+/**
 * The document every newly created model starts from: ownership, org membership, session/project
 * scoping, and the empty three-layer skeleton.
 *
@@ -3205,8 +3313,36 @@ function buildNewModel(user, options) {
 		updatedAt: now
 	};
 }
+/**
+* Get a model by ID with authorization check
+*/
+async function getModel(user, modelId, deps) {
+	const model = await deps.db.latticeModels.findById(modelId);
+	if (!model) return null;
+	return canReadModel(model, user) ? model : null;
+}
+/**
+* Get a model the caller may MUTATE, or null when they may not.
+*
+* Ownership only, and deliberately NARROWER than `getModel`. `getModel` is the READ gate and admits
+* same-org members by design (a model carries its creator's `organizationId`), but read access is
+* not write access - and every mutator took its authorization from it, so a colleague could rename,
+* re-value, re-rule or delete a model they did not create. Callers that only read keep using `getModel`: `listModels`,
+* `searchModels`, `hydrateModel` (computes derived values and stamps `lastComputedAt`), and
+* `duplicateModel` (reads one model and creates a NEW one owned by the caller).
+*
+* Lattice models carry no share/grant field, so the creator is the only principal that can hold
+* write authority today. If an explicit write grant is ever added, this is the one place to admit
+* it - keeping the check here rather than inlined in six mutators is what makes that a one-line
+* change instead of a six-site audit.
+*/
+async function getModelForWrite(user, modelId, deps) {
+	const model = await getModel(user, modelId, deps);
+	if (!model) return null;
+	return isModelOwner(model, user) ? model : null;
+}
 //#endregion
-//#region ../../b4m-core/services/dist/toolGenerators-iHwi8W0C.mjs
+//#region ../../b4m-core/services/dist/toolGenerators-DT6OlvUe.mjs
 const diceRoll = async (parameters) => {
 	if (!parameters?.sides || !parameters?.times) throw new Error("Tool dice roll: Missing required parameters");
 	return sum(times(parameters.times, () => random(1, parameters.sides))).toString();
@@ -3796,27 +3932,6 @@ const promptEnhancementTool = {
 		}
 	})
 };
-/**
-* Is this value shaped like something Mongoose can cast to an `_id`?
-*
-* Tool arguments are composed by the model out of conversation text and reach us as unvalidated
-* JSON, so an id parameter routinely holds something that is not an id at all - a filename token,
-* an arXiv number, a bare integer. Mongoose casts `_id` and throws a CastError on those, which a
-* generic catch upstream then reports as an outage rather than the bad argument it is (#2530).
-* Call this before handing a model-supplied id to `findById` and answer a false the same way the
-* surface answers a genuinely missing row.
-*
-* `isObjectIdOrHexString`, not `isValidObjectId`: the latter also accepts a number and casts it to
-* a fabricated id, and a model emitting `{"file_id": 12}` gives us exactly that despite the
-* `string` type. Same choice, same reason, as `usableObjectIds` in @bike4mind/db-core, which is
-* the array-shaped version of this check.
-*
-* NOT usable for artifact ids (`artifact_<...>`), which are matched on a string `id` field rather
-* than `_id` - see `createArtifactId` in @bike4mind/common.
-*/
-function isObjectIdShaped$1(id) {
-	return isObjectIdOrHexString(id);
-}
 let _showUserQuestion = null;
 /**
 * Inject the CLI callback that displays the question UI.
@@ -3936,7 +4051,7 @@ const askUserQuestionTool = {
 * re-export them without pulling the full tool graph. `index.ts` re-exports them
 * so the server barrel's public API is unchanged.
 */
-const generateTools = (userId, user, logger, { db, retrievalFilter, kbScope, inlinedAttachmentIds, fullyInlinedAttachmentIds, suppressLakeArms, sessionRetrievalTags, sessionLakeScopeExplicit, sessionPreauthorizedLakeIds, questId, getAbortSignal }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, imageProcessorLambdaName, tools, allowedDirectories, entitlementKeys = [], sessionId, codeMinifier, availableModels, onToolLlmUsage) => {
+const generateTools = (userId, user, logger, { db, retrievalFilter, kbScope, inlinedAttachmentIds, attachedFileIds, fullyInlinedAttachmentIds, suppressLakeArms, sessionRetrievalTags, sessionReaderConsentDatalakeTags, sessionLakeScopeExplicit, sessionIncludeLibraryFiles, sessionPreauthorizedLakeIds, organizationId, apiKeyId, questId, getAbortSignal }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model, imageProcessorLambdaName, tools, allowedDirectories, entitlementKeys = [], sessionId, codeMinifier, availableModels, onToolLlmUsage) => {
 	const context = {
 		userId,
 		user,
@@ -3957,32 +4072,61 @@ const generateTools = (userId, user, logger, { db, retrievalFilter, kbScope, inl
 		retrievalFilter,
 		kbScope,
 		inlinedAttachmentIds,
+		attachedFileIds,
 		fullyInlinedAttachmentIds,
 		suppressLakeArms,
 		sessionRetrievalTags,
+		sessionReaderConsentDatalakeTags,
 		sessionLakeScopeExplicit,
+		sessionIncludeLibraryFiles,
 		sessionPreauthorizedLakeIds,
+		organizationId,
+		apiKeyId,
 		codeMinifier,
 		availableModels,
 		onToolLlmUsage,
 		getAbortSignal
 	};
-	return Object.entries(tools).reduce((acc, [key, tool]) => ({
-		...acc,
-		[key]: tool.implementation(context, config[key])
-	}), {});
+	return Object.entries(tools).reduce((acc, [key, tool]) => {
+		const built = tool.implementation(context, config[key]);
+		return {
+			...acc,
+			[key]: tool.artifactType ? {
+				...built,
+				artifactType: tool.artifactType
+			} : built
+		};
+	}, {});
 };
 /**
+* MCP tool args only the confirm-button handlers may set. Those handlers call the MCP host
+* directly, never through these generators, so a model-originated call carrying one is forged.
+* `_executeFromButton` mirrors the button-only keys of `confirmationParams` in
+* b4m-core/mcp/src/shared/schemas.ts (pinned by github/__tests__/helpers/schemas.test.ts there);
+* `_confirmToken` is the preview token tools return.
+*/
+const SERVER_ONLY_MCP_ARG_KEYS = ["_executeFromButton", "_confirmToken"];
+const isPlainObject$1 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function stripServerOnlyArgs(args) {
+	if (!isPlainObject$1(args)) return args;
+	return Object.fromEntries(Object.entries(args).filter(([key]) => !SERVER_ONLY_MCP_ARG_KEYS.includes(key)));
+}
+/**
 * Normalize MCP tool parameters for OpenAI compatibility.
 * OpenAI requires 'properties' on object schemas - MCP tools like current_user
 * return { type: 'object' } without it, causing 400 errors.
 */
 function normalizeToolParameters(rest) {
 	const rawParameters = rest?.input_schema ?? rest?.inputSchema ?? rest?.parameters;
-	if (rawParameters && typeof rawParameters === "object") return {
-		...rawParameters,
-		properties: rawParameters.properties ?? {}
-	};
+	if (isPlainObject$1(rawParameters)) {
+		const properties = isPlainObject$1(rawParameters.properties) ? stripServerOnlyArgs(rawParameters.properties) : rawParameters.properties ?? {};
+		const required = Array.isArray(rawParameters.required) ? rawParameters.required.filter((key) => typeof key !== "string" || !SERVER_ONLY_MCP_ARG_KEYS.includes(key)) : rawParameters.required;
+		return {
+			...rawParameters,
+			properties,
+			...required !== void 0 ? { required } : {}
+		};
+	}
 	return {
 		type: "object",
 		properties: {},
@@ -4015,7 +4159,7 @@ const generateMcpTools = async (mcpData) => {
 			toolFn: async (args) => {
 				Logger.debug(`Calling ${originalToolName} tool via ${mcpData.serverName}`, args);
 				try {
-					const toolResult = await mcpData.callTool(originalToolName, args);
+					const toolResult = await mcpData.callTool(originalToolName, stripServerOnlyArgs(args));
 					const contentBlocks = toolResult?.content;
 					if (Array.isArray(contentBlocks) && contentBlocks.length > 0) {
 						const normalized = contentBlocks.map((entry) => {
@@ -4067,7 +4211,7 @@ const generateMcpToolsFromCache = (serverName, cachedTools, callTool) => {
 			toolFn: async (args) => {
 				Logger.debug(`Calling ${originalToolName} tool via ${serverName}`, args);
 				try {
-					const toolResult = await callTool(originalToolName, args);
+					const toolResult = await callTool(originalToolName, stripServerOnlyArgs(args));
 					const contentBlocks = toolResult?.content;
 					if (Array.isArray(contentBlocks) && contentBlocks.length > 0) {
 						const normalized = contentBlocks.map((entry) => {
@@ -4104,6 +4248,29 @@ const generateMcpToolsFromCache = (serverName, cachedTools, callTool) => {
 	return result;
 };
 //#endregion
+//#region ../../b4m-core/services/dist/objectId-DTad97PS.mjs
+/**
+* Is this value shaped like something Mongoose can cast to an `_id`?
+*
+* Tool arguments are composed by the model out of conversation text and reach us as unvalidated
+* JSON, so an id parameter routinely holds something that is not an id at all - a filename token,
+* an arXiv number, a bare integer. Mongoose casts `_id` and throws a CastError on those, which a
+* generic catch upstream then reports as an outage rather than the bad argument it is (#2530).
+* Call this before handing a model-supplied id to `findById` and answer a false the same way the
+* surface answers a genuinely missing row.
+*
+* `isObjectIdOrHexString`, not `isValidObjectId`: the latter also accepts a number and casts it to
+* a fabricated id, and a model emitting `{"file_id": 12}` gives us exactly that despite the
+* `string` type. Same choice, same reason, as `usableObjectIds` in @bike4mind/db-core, which is
+* the array-shaped version of this check.
+*
+* NOT usable for artifact ids (`artifact_<...>`), which are matched on a string `id` field rather
+* than `_id` - see `createArtifactId` in @bike4mind/common.
+*/
+function isObjectIdShaped(id) {
+	return isObjectIdOrHexString(id);
+}
+//#endregion
 //#region ../../b4m-core/services/dist/llm/tools/cliTools.mjs
 /**
 * Validated fuzzy fallback for `edit_local_file` string matching.
@@ -5493,35 +5660,29 @@ const latticeAddEntityTool = {
 				createdAt: /* @__PURE__ */ new Date(),
 				updatedAt: /* @__PURE__ */ new Date()
 			};
-			if (context.db.latticeModels && modelId && isObjectIdShaped$1(modelId)) try {
-				const model = await context.db.latticeModels.findById(modelId);
-				if (model && isModelOwner(model, { id: context.userId })) {
-					const existingIndex = model.data.entities.findIndex((e) => e.id === entityId);
-					if (existingIndex >= 0) model.data.entities[existingIndex] = entityData;
-					else model.data.entities.push(entityData);
-					await context.db.latticeModels.update({
-						id: modelId,
-						data: model.data,
-						updatedAt: /* @__PURE__ */ new Date()
-					});
-					context.logger.info(`[Lattice] Added entity ${entityId} to model ${modelId}`);
-				} else if (model) {
-					context.logger.warn(`[Lattice] Access denied: caller does not own model ${modelId}`);
+			if (context.db.latticeModels && modelId && isObjectIdShaped(modelId)) try {
+				const model = await getModelForWrite({
+					id: context.userId,
+					organizationId: context.user?.organizationId
+				}, modelId, { db: { latticeModels: context.db.latticeModels } });
+				if (!model) {
+					context.logger.warn(`[Lattice] Model ${modelId} not found or access denied for user ${context.userId}`);
 					return JSON.stringify({
 						success: false,
 						action: "ADD_ENTITY",
 						modelId,
-						error: `Access denied: you do not have permission to modify model ${modelId}`
-					});
-				} else {
-					context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
-					return JSON.stringify({
-						success: false,
-						action: "ADD_ENTITY",
-						modelId,
-						error: `Model ${modelId} not found`
+						error: `Model ${modelId} not found or you do not have permission to modify it`
 					});
 				}
+				const existingIndex = model.data.entities.findIndex((e) => e.id === entityId);
+				if (existingIndex >= 0) model.data.entities[existingIndex] = entityData;
+				else model.data.entities.push(entityData);
+				await context.db.latticeModels.update({
+					id: modelId,
+					data: model.data,
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+				context.logger.info(`[Lattice] Added entity ${entityId} to model ${modelId}`);
 			} catch (error) {
 				context.logger.error(`[Lattice] Failed to persist entity to database:`, error);
 				return JSON.stringify({
@@ -5643,52 +5804,46 @@ const latticeSetValueTool = {
 			else if (rawValue.toLowerCase() === "true") value = true;
 			else if (rawValue.toLowerCase() === "false") value = false;
 			const entityId = toEntityId(entityName);
-			if (context.db.latticeModels && modelId && isObjectIdShaped$1(modelId)) try {
-				const model = await context.db.latticeModels.findById(modelId);
-				if (model && isModelOwner(model, { id: context.userId })) {
-					const entity = model.data.entities.find((e) => e.id === entityId || toEntityId(e.name) === entityId);
-					if (!entity) {
-						context.logger.warn(`[Lattice] Entity ${entityName} not found in model ${modelId}`);
-						return JSON.stringify({
-							success: false,
-							action: "SET_VALUE",
-							modelId,
-							error: entityNotFoundError(model.data.entities, entityName, attributeKey)
-						});
-					}
-					const attrIndex = entity.attributes.findIndex((a) => a.key === attributeKey);
-					const attributeData = {
-						key: attributeKey,
-						value,
-						dataType: typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string",
-						isComputed: false
-					};
-					if (attrIndex >= 0) entity.attributes[attrIndex] = attributeData;
-					else entity.attributes.push(attributeData);
-					entity.updatedAt = /* @__PURE__ */ new Date();
-					await context.db.latticeModels.update({
-						id: modelId,
-						data: model.data,
-						updatedAt: /* @__PURE__ */ new Date()
-					});
-					context.logger.info(`[Lattice] Set ${entityId}.${attributeKey} = ${value} in model ${modelId}`);
-				} else if (model) {
-					context.logger.warn(`[Lattice] Access denied: caller does not own model ${modelId}`);
+			if (context.db.latticeModels && modelId && isObjectIdShaped(modelId)) try {
+				const model = await getModelForWrite({
+					id: context.userId,
+					organizationId: context.user?.organizationId
+				}, modelId, { db: { latticeModels: context.db.latticeModels } });
+				if (!model) {
+					context.logger.warn(`[Lattice] Model ${modelId} not found or access denied for user ${context.userId}`);
 					return JSON.stringify({
 						success: false,
 						action: "SET_VALUE",
 						modelId,
-						error: `Access denied: you do not have permission to modify model ${modelId}`
+						error: `Model ${modelId} not found or you do not have permission to modify it`
 					});
-				} else {
-					context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
+				}
+				const entity = model.data.entities.find((e) => e.id === entityId || toEntityId(e.name) === entityId);
+				if (!entity) {
+					context.logger.warn(`[Lattice] Entity ${entityName} not found in model ${modelId}`);
 					return JSON.stringify({
 						success: false,
 						action: "SET_VALUE",
 						modelId,
-						error: `Model ${modelId} not found`
+						error: entityNotFoundError(model.data.entities, entityName, attributeKey)
 					});
 				}
+				const attrIndex = entity.attributes.findIndex((a) => a.key === attributeKey);
+				const attributeData = {
+					key: attributeKey,
+					value,
+					dataType: typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string",
+					isComputed: false
+				};
+				if (attrIndex >= 0) entity.attributes[attrIndex] = attributeData;
+				else entity.attributes.push(attributeData);
+				entity.updatedAt = /* @__PURE__ */ new Date();
+				await context.db.latticeModels.update({
+					id: modelId,
+					data: model.data,
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+				context.logger.info(`[Lattice] Set ${entityId}.${attributeKey} = ${value} in model ${modelId}`);
 			} catch (error) {
 				context.logger.error(`[Lattice] Failed to persist value to database:`, error);
 				return JSON.stringify({
@@ -5794,62 +5949,56 @@ const latticeCreateRuleTool = {
 			};
 			const outputEntityId = parsedRule.outputEntity.toLowerCase().replace(/\s+/g, "_");
 			let entityCreatedMessage = "";
-			if (context.db.latticeModels && modelId && isObjectIdShaped$1(modelId)) try {
-				const model = await context.db.latticeModels.findById(modelId);
-				if (model && isModelOwner(model, { id: context.userId })) {
-					if (!model.data.entities.some((e) => e.id === outputEntityId || e.name.toLowerCase() === parsedRule.outputEntity.toLowerCase()) && parsedRule.outputEntity !== "unknown") {
-						const now = /* @__PURE__ */ new Date();
-						const newEntity = {
-							id: outputEntityId,
-							type: "line_item",
-							name: parsedRule.outputEntity,
-							displayName: parsedRule.outputEntity,
-							attributes: [{
-								key: "value",
-								value: 0,
-								dataType: "currency",
-								isComputed: true
-							}, {
-								key: "category",
-								value: "Computed",
-								dataType: "string",
-								isComputed: false
-							}],
-							metadata: { isComputed: true },
-							createdAt: now,
-							updatedAt: now
-						};
-						model.data.entities.push(newEntity);
-						entityCreatedMessage = ` Created output entity "${parsedRule.outputEntity}".`;
-						context.logger.info(`[Lattice] Auto-created output entity ${outputEntityId} for rule ${ruleId}`);
-					}
-					const existingIndex = model.rules.rules.findIndex((r) => r.id === ruleId || r.name === name);
-					if (existingIndex >= 0) model.rules.rules[existingIndex] = ruleData;
-					else model.rules.rules.push(ruleData);
-					await context.db.latticeModels.update({
-						id: modelId,
-						data: model.data,
-						rules: model.rules,
-						updatedAt: /* @__PURE__ */ new Date()
-					});
-					context.logger.info(`[Lattice] Created rule ${ruleId} in model ${modelId}`);
-				} else if (model) {
-					context.logger.warn(`[Lattice] Access denied: caller does not own model ${modelId}`);
+			if (context.db.latticeModels && modelId && isObjectIdShaped(modelId)) try {
+				const model = await getModelForWrite({
+					id: context.userId,
+					organizationId: context.user?.organizationId
+				}, modelId, { db: { latticeModels: context.db.latticeModels } });
+				if (!model) {
+					context.logger.warn(`[Lattice] Model ${modelId} not found or access denied for user ${context.userId}`);
 					return JSON.stringify({
 						success: false,
 						action: "CREATE_RULE",
 						modelId,
-						error: `Access denied: you do not have permission to modify model ${modelId}`
-					});
-				} else {
-					context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
-					return JSON.stringify({
-						success: false,
-						action: "CREATE_RULE",
-						modelId,
-						error: `Model ${modelId} not found`
+						error: `Model ${modelId} not found or you do not have permission to modify it`
 					});
 				}
+				if (!model.data.entities.some((e) => e.id === outputEntityId || e.name.toLowerCase() === parsedRule.outputEntity.toLowerCase()) && parsedRule.outputEntity !== "unknown") {
+					const now = /* @__PURE__ */ new Date();
+					const newEntity = {
+						id: outputEntityId,
+						type: "line_item",
+						name: parsedRule.outputEntity,
+						displayName: parsedRule.outputEntity,
+						attributes: [{
+							key: "value",
+							value: 0,
+							dataType: "currency",
+							isComputed: true
+						}, {
+							key: "category",
+							value: "Computed",
+							dataType: "string",
+							isComputed: false
+						}],
+						metadata: { isComputed: true },
+						createdAt: now,
+						updatedAt: now
+					};
+					model.data.entities.push(newEntity);
+					entityCreatedMessage = ` Created output entity "${parsedRule.outputEntity}".`;
+					context.logger.info(`[Lattice] Auto-created output entity ${outputEntityId} for rule ${ruleId}`);
+				}
+				const existingIndex = model.rules.rules.findIndex((r) => r.id === ruleId || r.name === name);
+				if (existingIndex >= 0) model.rules.rules[existingIndex] = ruleData;
+				else model.rules.rules.push(ruleData);
+				await context.db.latticeModels.update({
+					id: modelId,
+					data: model.data,
+					rules: model.rules,
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+				context.logger.info(`[Lattice] Created rule ${ruleId} in model ${modelId}`);
 			} catch (error) {
 				context.logger.error(`[Lattice] Failed to persist rule to database:`, error);
 				return JSON.stringify({
@@ -6041,7 +6190,8 @@ This tool traces the calculation chain from the target value back through all it
 * This is a simplified implementation - production would use LLM structured output
 */
 function parseFormula(formula) {
-	const equalsMatch = splitEquals(formula.toLowerCase().trim());
+	const normalized = formula.toLowerCase().trim();
+	const equalsMatch = splitEquals(normalized);
 	if (equalsMatch) {
 		const [output, expression] = equalsMatch;
 		if (expression.includes("+") || expression.includes("plus")) return {
@@ -9128,16 +9278,24 @@ function leadingProgram(args) {
 	return index < args.length ? programName(args[index]) : "";
 }
 /**
-* True if any `>`/`>>` redirection targets a raw block device. Covers the common
-* host shapes: SCSI/SATA (`sd[a-z]`), NVMe, Xen (`xvd[a-z]`, default on many EC2
-* AMIs), virtio (`vd[a-z]`), legacy IDE (`hd[a-z]`), device-mapper/LVM (`dm-N`,
-* `mapper/`), software RAID (`md N`), eMMC/SD (`mmcblkN`), loop, and macOS `diskN`.
+* True if any write redirection (`>`, `>>`, `>|`, `&>`, `&>>`, `<>`) targets a raw block
+* device. Covers the common host shapes: SCSI/SATA (`sd[a-z]`), NVMe, Xen (`xvd[a-z]`,
+* default on many EC2 AMIs), virtio (`vd[a-z]`), legacy IDE (`hd[a-z]`), device-mapper/LVM
+* (`dm-N`, `mapper/`), software RAID (`md N`), eMMC/SD (`mmcblkN`), loop, and macOS `diskN`.
 */
 const BLOCK_DEVICE_RE = /^\/dev\/(sd[a-z]|nvme\d+n\d+|xvd[a-z]|vd[a-z]|hd[a-z]|dm-\d+|md\d+|mmcblk\d+|loop\d+|disk\d+|mapper\/)/;
+const WRITE_REDIRECT_OPS = /* @__PURE__ */ new Set([
+	">",
+	">>",
+	">|",
+	"&>",
+	"&>>",
+	"<>"
+]);
 function writesToBlockDevice(tokens) {
 	for (let i = 0; i < tokens.length; i += 1) {
 		const token = tokens[i];
-		if (isOperator(token) && (token.op === ">" || token.op === ">>")) {
+		if (isOperator(token) && WRITE_REDIRECT_OPS.has(token.op)) {
 			let targetIndex = i + 1;
 			const following = tokens[targetIndex];
 			if (isOperator(following) && following.op === "|") targetIndex += 1;
@@ -9681,6 +9839,13 @@ var CliLogger = class extends Logger {
 	debug(...args) {}
 	log(...args) {}
 };
+const FILE_WRITE_SUCCESS = /^File (edited|created|overwritten) successfully: /;
+const FILE_WRITE_TOOLS = /* @__PURE__ */ new Set(["edit_local_file", "create_file"]);
+function notifyFileChanged(agentContext, toolName, args, result) {
+	if (!agentContext.onFileChanged || !FILE_WRITE_TOOLS.has(toolName)) return;
+	if (typeof args.path !== "string" || !FILE_WRITE_SUCCESS.test(result)) return;
+	agentContext.onFileChanged(args.path);
+}
 /**
 * Wrap a tool with permission checking, server routing, and observation tracking.
 */
@@ -9727,8 +9892,8 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
 				} else if (decision.type === "unsandboxed") sandboxOrchestrator.recordUnsandboxed();
 			}
 			const effectiveArgs = isSandboxed ? sandboxedArgs : args;
-			const { gateSnapshot: _modelSuppliedGateSnapshot, ...effectiveArgsSansGateSnapshot } = effectiveArgs ?? {};
-			let execArgs = effectiveArgsSansGateSnapshot;
+			const { gateSnapshot: _modelSuppliedGateSnapshot, confirmedFuzzyHash: _modelSuppliedFuzzyHash, ...effectiveArgsSansGateFields } = effectiveArgs ?? {};
+			let execArgs = effectiveArgsSansGateFields;
 			const sandboxCleanupPaths = isSandboxed ? sandboxedArgs?._sandboxCleanup : void 0;
 			/**
 			* Shared execution flow: run tool, capture violations, offer retry on
@@ -9750,6 +9915,7 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
 					toolName,
 					result
 				});
+				notifyFileChanged(agentContext, toolName, execArgs, result);
 				getProcessHooks()?.firePostToolUse(toolName);
 				return result;
 			}
@@ -10767,6 +10933,25 @@ function appendWorkflowReminder(messages, provider) {
 		content: `${WORKFLOW_REMINDER_MARKER}\n${body}`
 	});
 }
+const TOOL_RESULTS_NUDGE = "Based on the tool results above, please provide a complete answer. If I asked for multiple things, make sure to address all of them.";
+/**
+* The end-of-iteration nudge, with any drained host feedback folded in. Folding
+* (rather than pushing a second plain-string user message) keeps exactly one
+* iteration boundary for findIterationBoundary's trimming heuristic.
+*/
+function buildToolResultsNudge(feedback) {
+	return feedback ? `${TOOL_RESULTS_NUDGE}\n\n${feedback}` : TOOL_RESULTS_NUDGE;
+}
+/** Calls the host's feedback drain. A failing drain is logged and treated as empty - it must never fail the run. */
+async function drainHostFeedback(drain, phase, logger) {
+	if (!drain) return null;
+	try {
+		return (await drain(phase))?.trim() || null;
+	} catch (error) {
+		logger.warn(`[ReActAgent] drainFeedback(${phase}) failed; continuing without feedback:`, error);
+		return null;
+	}
+}
 /**
 * Build the per-iteration prompt-cache strategy. History caching anchors on the
 * last message so the cached prefix grows each turn (standard Anthropic
@@ -11146,7 +11331,9 @@ var ReActAgent = class extends EventEmitter {
 					}
 					throw completionError;
 				}
-				if (!hadToolCalls && currentText.trim()) {
+				const finalFeedback = !hadToolCalls && currentText.trim() && iterations < maxIterations ? await drainHostFeedback(options.drainFeedback, "final", this.context.logger) : null;
+				if (finalFeedback) this.reopenAnswerWithFeedback(messages, currentText.trim(), finalFeedback);
+				else if (!hadToolCalls && currentText.trim()) {
 					finalAnswer = currentText.trim();
 					const iterInputTokens = this.totalInputTokens - preCallTotalInputTokens;
 					const iterOutputTokens = this.totalOutputTokens - preCallTotalOutputTokens;
@@ -11194,10 +11381,13 @@ var ReActAgent = class extends EventEmitter {
 					});
 				}
 				this.iterationConfidences = [];
-				if (!iterationComplete && hadToolCalls) messages.push({
-					role: "user",
-					content: `Based on the tool results above, please provide a complete answer. If I asked for multiple things, make sure to address all of them.`
-				});
+				if (!iterationComplete && hadToolCalls) {
+					const feedback = await drainHostFeedback(options.drainFeedback, "turn", this.context.logger);
+					messages.push({
+						role: "user",
+						content: buildToolResultsNudge(feedback)
+					});
+				}
 				if (maxTotalTokens !== void 0 && this.totalTokens >= maxTotalTokens && !iterationComplete) {
 					reachedMaxTotalTokens = true;
 					finalAnswer = currentText.trim() || `I stopped after reaching the cumulative token ceiling (${this.totalTokens}/${maxTotalTokens}) without arriving at a final answer.`;
@@ -11311,6 +11501,29 @@ BEHAVIOR GUIDELINES:
 Remember: You are an autonomous AGENT. Act independently and solve problems proactively.`;
 	}
 	/**
+	* Demote a would-be final answer to a thought and hand the model drained host
+	* feedback (see AgentRunOptions.drainFeedback) as the next user message, so
+	* the loop runs another iteration instead of ending. The user message is a
+	* plain string and so is a normal iteration boundary for trimming.
+	*/
+	reopenAnswerWithFeedback(messages, answer, feedback) {
+		const thoughtStep = {
+			type: "thought",
+			content: answer,
+			metadata: { timestamp: Date.now() }
+		};
+		this.steps.push(thoughtStep);
+		this.emit("thought", thoughtStep);
+		messages.push({
+			role: "assistant",
+			content: answer
+		}, {
+			role: "user",
+			content: feedback
+		});
+		return thoughtStep;
+	}
+	/**
 	* Add an observation step (used by tool wrappers to record tool results).
 	* Kept for backwards compatibility but no longer used. Observations are now
 	* queued and drained in the completion callback for correct ordering.
@@ -11689,7 +11902,9 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
 					}
 				}
 			});
-			if (!hadToolCalls && currentText.trim()) {
+			const finalFeedback = !hadToolCalls && currentText.trim() && this.iterations < maxIterations ? await drainHostFeedback(options.drainFeedback, "final", this.context.logger) : null;
+			if (finalFeedback) iterationSteps.push(this.reopenAnswerWithFeedback(this.messages, currentText.trim(), finalFeedback));
+			else if (!hadToolCalls && currentText.trim()) {
 				finalAnswer = currentText.trim();
 				const iterInputTokens = this.totalInputTokens - iterStartInputTokens;
 				const iterOutputTokens = this.totalOutputTokens - iterStartOutputTokens;
@@ -11746,10 +11961,13 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
 				});
 			}
 			this.iterationConfidences = [];
-			if (!iterationComplete && hadToolCalls) this.messages.push({
-				role: "user",
-				content: "Based on the tool results above, please provide a complete answer. If I asked for multiple things, make sure to address all of them."
-			});
+			if (!iterationComplete && hadToolCalls) {
+				const feedback = await drainHostFeedback(options.drainFeedback, "turn", this.context.logger);
+				this.messages.push({
+					role: "user",
+					content: buildToolResultsNudge(feedback)
+				});
+			}
 			if (!iterationComplete && maxTotalTokens !== void 0 && this.totalTokens >= maxTotalTokens) {
 				finalAnswer = currentText.trim() || `I stopped after reaching the cumulative token ceiling (${this.totalTokens}/${maxTotalTokens}) without arriving at a final answer.`;
 				const ceilingStep = {
@@ -15704,6 +15922,10 @@ var StreamAccumulator = class {
 	isEmpty() {
 		return this.accumulatedText.trim().length === 0 && this.toolsUsed.length === 0;
 	}
+	/** The stop reason the stream reported, if any: its presence means the stream ended normally. */
+	get finalStopReason() {
+		return this.stopReason;
+	}
 	get accumulatedLength() {
 		return this.accumulatedText.length;
 	}
@@ -15749,6 +15971,19 @@ var EmptyCompletionError = class extends Error {
 		this.name = "EmptyCompletionError";
 	}
 };
+/**
+* Thrown when a stream finished normally (it carried a stop reason) but produced no reply,
+* e.g. a reasoning model that spent its whole output budget thinking: the server drops
+* reasoning text, so such a turn arrives blank. Not retried - the same request would
+* finish the same way and be billed again.
+*/
+var NoReplyCompletionError = class extends Error {
+	constructor(stopReason) {
+		super(stopReason === "max_tokens" ? "The model used its whole output limit on reasoning and produced no reply. Raise the max tokens setting or ask a narrower question." : `The model finished (stop reason: ${stopReason}) without producing a reply.`);
+		this.stopReason = stopReason;
+		this.name = "NoReplyCompletionError";
+	}
+};
 /** User-facing message when a transient network drop survives all retries. */
 const TRANSIENT_EXHAUSTED_MESSAGE = "The connection dropped mid-response (likely a network timeout during a long thinking step). It was retried automatically but kept failing - type \"continue\" to resume.";
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -15793,12 +16028,13 @@ async function runCompletion(transport, req, callback, policy, signal) {
 				await accumulator.finalize(callback);
 				return;
 			}
+			if (accumulator.finalStopReason) throw new NoReplyCompletionError(accumulator.finalStopReason);
 			lastError = new EmptyCompletionError();
 			logger.warn("[runCompletion] Stream produced no content; treating as retryable.");
 		} catch (error) {
 			lastError = error instanceof Error ? error : new Error(String(error));
 			if (signal?.aborted) return;
-			if (!policy.isRetryable(lastError)) throw lastError;
+			if (lastError instanceof NoReplyCompletionError || !policy.isRetryable(lastError)) throw lastError;
 			logger.warn(`[runCompletion] Transient stream failure (attempt ${attempt + 1}): ${lastError.message}`);
 		}
 		if (attempt < policy.maxRetries && backoffMs > 0) await sleep(backoffMs * (attempt + 1));
@@ -16069,10 +16305,10 @@ var ServerLlmBackend = class {
 					} else if (typeof stream === "string") responseText = stream;
 					logger.debug(`[ServerLlmBackend] Response preview: ${responseText.substring(0, 200)}`);
 					if (responseText.includes("<!DOCTYPE") || responseText.includes("<html")) {
-						const titleMatch = responseText.match(/<title>(.*?)<\/title>/i);
-						const h1Match = responseText.match(/<h1>(.*?)<\/h1>/i);
-						if (titleMatch && titleMatch[1] !== "Error") errorDetails = titleMatch[1].trim();
-						else if (h1Match) errorDetails = h1Match[1].trim();
+						const title = htmlErrorTitle(responseText);
+						const h1 = htmlFirstH1(responseText);
+						if (title !== null) errorDetails = title;
+						else if (h1 !== null) errorDetails = h1.trim();
 					} else if (responseText) errorDetails = responseText.substring(0, 100).trim();
 				} catch (extractError) {
 					logger.error("[ServerLlmBackend] Error extracting response:", extractError);