blun-king-cli 9.1.594 → 9.1.595

package/blun.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:410be0cd699a00876404e3f2e9a6d091b2c2fa9c4bb1f483b7fbdd3480a39fb2
+// BLUN_BUILD_INPUT_SHA256:bb2a99b699d299ac283bd9b157d0c18555ae0ab62c58c7b3c10d8311dfa87a0d
 import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
@@ -234565,10 +234565,11 @@ var init_context$2 = __esmMin((() => {
 						const openStepIndex = openStep === void 0 ? -1 : this._history.indexOf(openStep);
 						const coveredCount = openStepIndex === -1 ? this._history.length : openStepIndex + 1;
 						const totalUsage = event.usage.inputCacheRead + event.usage.inputCacheCreation + event.usage.inputOther + event.usage.output;
-						if (totalUsage > 0) this._tokenCount = totalUsage;
+						if (totalUsage > 0 && event.contextCoverage !== "partial") this._tokenCount = totalUsage;
 						else {
 							const previousCoveredCount = this.tokenCountCoveredMessageCount;
 							this._tokenCount += estimateTokensForMessages(this._history.slice(previousCoveredCount, coveredCount));
+							this._tokenCount = Math.max(this._tokenCount, totalUsage);
 						}
 						this.tokenCountCoveredMessageCount = coveredCount;
 					}
@@ -238580,9 +238581,524 @@ var init_auto_mode_ask_user_question_deny = __esmMin((() => {
 	};
 }));
 //#endregion
+//#region ../../packages/agent-core/src/agent/turn/turn-tool-performance-policy.cjs
+var require_turn_tool_performance_policy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const TOOL_SCHEMA_BUDGET_RATIO = .25;
+	const TOOL_SCHEMA_MAX_TOKENS = 64e3;
+	const DEFERRED_TOOL_LOADER_NAME = "ToolSearch";
+	const MAX_PERSISTENT_DEFERRED_TOOLS = 12;
+	const MAX_TOOL_SEARCH_QUERY_CHARS = 1e3;
+	const MAX_AUTO_RANKED_TOOLS = 6;
+	const deferredToolLoaders = /* @__PURE__ */ new WeakSet();
+	const TOOL_RANK_EMBEDDED_CONTENT_RE = /<(attached_documents?|attachment_content|document_content|file_content)\b[^>]*>[\s\S]*?<\/\1>/giu;
+	const TOOL_RANK_STOP_WORDS = new Set([
+		"aber",
+		"also",
+		"and",
+		"aus",
+		"bitte",
+		"can",
+		"das",
+		"den",
+		"der",
+		"des",
+		"die",
+		"dies",
+		"diese",
+		"du",
+		"ein",
+		"eine",
+		"einer",
+		"eines",
+		"for",
+		"fuer",
+		"für",
+		"haben",
+		"ich",
+		"ist",
+		"kann",
+		"kannst",
+		"mal",
+		"me",
+		"mein",
+		"meine",
+		"mir",
+		"mit",
+		"of",
+		"please",
+		"soll",
+		"the",
+		"und",
+		"uns",
+		"von",
+		"was",
+		"wir",
+		"with",
+		"you",
+		"zeige",
+		"zeig",
+		"pruefe",
+		"prüfe",
+		"lies",
+		"read",
+		"show",
+		"get"
+	]);
+	const TOOL_SEARCH_INTENT_WORDS = new Set([
+		"find",
+		"fetch",
+		"get",
+		"holen",
+		"list",
+		"read",
+		"search",
+		"show",
+		"anzeigen",
+		"lesen",
+		"suchen"
+	]);
+	const TOOL_SEARCH_RELATED_TERM_GROUPS = Object.freeze([
+		Object.freeze([
+			"checklist",
+			"list",
+			"liste",
+			"listen"
+		]),
+		Object.freeze([
+			"aufgabe",
+			"aufgaben",
+			"aufgabenliste",
+			"todo",
+			"todos"
+		]),
+		Object.freeze([
+			"current",
+			"inbox",
+			"latest",
+			"message",
+			"messages",
+			"nachricht",
+			"nachrichten",
+			"queue",
+			"queued",
+			"recent",
+			"letzte",
+			"letzten",
+			"letzter",
+			"vergangen",
+			"update",
+			"updates"
+		]),
+		Object.freeze([
+			"chat",
+			"conversation",
+			"history",
+			"log",
+			"logs",
+			"processed",
+			"protokoll",
+			"transcript",
+			"verlauf"
+		]),
+		Object.freeze([
+			"fact",
+			"facts",
+			"fakt",
+			"fakten",
+			"memory",
+			"memories",
+			"merk",
+			"merken",
+			"note",
+			"notes",
+			"persist",
+			"persistent",
+			"profile",
+			"remember",
+			"save",
+			"speichern",
+			"store"
+		])
+	]);
+	const TOOL_SEARCH_SINGLE_TERM_RELATED_FALLBACKS = new Set([
+		"fact",
+		"facts",
+		"fakt",
+		"fakten",
+		"memory",
+		"memories",
+		"merk",
+		"merken",
+		"note",
+		"notes",
+		"persist",
+		"persistent",
+		"profile",
+		"remember",
+		"save",
+		"speichern",
+		"store",
+		"transcript"
+	]);
+	const CORE_TOOL_NAMES = Object.freeze([
+		"Bash",
+		"Read",
+		"ReadBatch",
+		"Edit",
+		"Grep",
+		"Write",
+		"Glob",
+		"TodoList",
+		"mcp__plugin-telegram_telegram__reply"
+	]);
+	const IMAGE_MEDIA_TERM_RE = /(?:^|[^\p{L}])(?:bild(?:er)?|foto(?:s)?|grafik(?:en)?|illustration(?:en)?|logo(?:s)?|image|images|photo|photos|picture|pictures|illustration|illustrations|visual|visuals)(?=$|[^\p{L}])/u;
+	const VIDEO_MEDIA_TERM_RE = /(?:^|[^\p{L}])(?:video(?:s)?|clip(?:s)?|film(?:e)?|animation(?:en)?|movie|movies)(?=$|[^\p{L}])/u;
+	const ANIMATE_ACTION_RE = /(?:^|[^\p{L}])(?:animier(?:e|en|t)?|animate|animated|animating)(?=$|[^\p{L}])/u;
+	const CREATE_ACTION_RE = /(?:^|[^\p{L}])(?:erstell(?:e|en|t)?|generier(?:e|en|t)?|erzeug(?:e|en|t)?|produzier(?:e|en|t)?|zeichn(?:e|en|et)?|mal(?:e|en|t)?|render(?:e|n|t)?|mach(?:e|en|t)?|create|creates|creating|generate|generates|generating|make|makes|making|draw|draws|drawing|paint|paints|painting|render|renders|rendering|produce|produces|producing)(?=$|[^\p{L}])/u;
+	const REQUEST_PREFIX_RE = /^(?:bitte\s+|please\s+)?(?:erstell|generier|erzeug|produzier|zeichn|mal|render|mach|animier|create|generate|make|draw|paint|render|produce|animate)/u;
+	const REQUEST_PHRASE_RE = /(?:^|[^\p{L}])(?:bitte|kannst du|könntest du|ich möchte|ich will|ich brauche|please|can you|could you|i want|i need)(?=$|[^\p{L}])/u;
+	function mediaGenerationToolNamesForText(value) {
+		const text = String(value || "").normalize("NFKC").trim().toLowerCase();
+		const selected = /* @__PURE__ */ new Set();
+		if (!text) return selected;
+		if (/(?:^|[^a-z])generateimage(?=$|[^a-z])/u.test(text)) selected.add("GenerateImage");
+		if (/(?:^|[^a-z])generatevideo(?=$|[^a-z])/u.test(text)) selected.add("GenerateVideo");
+		if (selected.size > 0) return selected;
+		const animate = ANIMATE_ACTION_RE.test(text);
+		const create = CREATE_ACTION_RE.test(text);
+		if (!(REQUEST_PREFIX_RE.test(text) || REQUEST_PHRASE_RE.test(text)) || !create && !animate) return selected;
+		if (animate && (IMAGE_MEDIA_TERM_RE.test(text) || VIDEO_MEDIA_TERM_RE.test(text))) {
+			selected.add("GenerateVideo");
+			return selected;
+		}
+		if (IMAGE_MEDIA_TERM_RE.test(text)) selected.add("GenerateImage");
+		if (VIDEO_MEDIA_TERM_RE.test(text)) selected.add("GenerateVideo");
+		return selected;
+	}
+	function mediaToolNamesForTurnText(value) {
+		const text = String(value || "");
+		const selected = /* @__PURE__ */ new Set();
+		const channelBodies = [...text.matchAll(/(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/giu)].map((match) => match[1]);
+		const intentTexts = channelBodies.length > 0 ? channelBodies : [text];
+		for (const intentText of intentTexts) for (const name of mediaGenerationToolNamesForText(intentText)) selected.add(name);
+		if (/\bimage_path\s*=\s*["'][^"']+["']/iu.test(text)) {
+			selected.add("ReadMediaFile");
+			selected.add("UnderstandImage");
+		}
+		if (/\battachment_file_id\s*=\s*["'][^"']+["']/iu.test(text)) {
+			selected.add("mcp__plugin-telegram_telegram__download_attachment");
+			selected.add("UnderstandImage");
+		}
+		return selected;
+	}
+	function toolSchemaBudgetTokens(maxContextTokens) {
+		const context = Number(maxContextTokens);
+		if (!Number.isFinite(context) || context <= 0) return TOOL_SCHEMA_MAX_TOKENS;
+		return Math.min(TOOL_SCHEMA_MAX_TOKENS, Math.floor(context * TOOL_SCHEMA_BUDGET_RATIO));
+	}
+	function deferredToolNames(tools) {
+		return [...new Set((Array.isArray(tools) ? tools : []).map((tool) => String(tool?.name || "").trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
+	}
+	function deferredToolCatalog(tools) {
+		const names = deferredToolNames(tools);
+		const leaves = names.map((name) => name.split(/__|:/).at(-1) || name);
+		const leafCounts = /* @__PURE__ */ new Map();
+		for (const leaf of leaves) leafCounts.set(leaf, (leafCounts.get(leaf) || 0) + 1);
+		return names.map((name, index) => leafCounts.get(leaves[index]) === 1 ? leaves[index] : name).sort((left, right) => left.localeCompare(right));
+	}
+	function normalizeDeferredToolQuery(value) {
+		const query = String(value ?? "").trim();
+		if (query.length <= MAX_TOOL_SEARCH_QUERY_CHARS) return query;
+		const bounded = query.slice(0, MAX_TOOL_SEARCH_QUERY_CHARS);
+		const wordBoundary = bounded.lastIndexOf(" ");
+		return (wordBoundary >= MAX_TOOL_SEARCH_QUERY_CHARS * .8 ? bounded.slice(0, wordBoundary) : bounded).trimEnd();
+	}
+	function searchDeferredTools(tools, query) {
+		const normalized = normalizeDeferredToolQuery(query).toLowerCase();
+		if (!normalized) return [];
+		if (normalized.startsWith("select:")) {
+			const selector = normalized.slice(7).trim();
+			if (!selector) return [];
+			const exact = tools.find((tool) => String(tool?.name || "").toLowerCase() === selector);
+			if (exact) return [exact];
+			return tools.filter((tool) => {
+				return String(tool?.name || "").toLowerCase().split(/__|:/).at(-1) === selector;
+			});
+		}
+		const tokens = normalized.split(/\s+/).filter(Boolean);
+		const requiredNameTokens = tokens.filter((token) => token.startsWith("+")).map((token) => token.slice(1)).filter(Boolean);
+		const searchTokens = tokens.filter((token) => !token.startsWith("+"));
+		const eligibleTools = tools.filter((tool) => {
+			const name = String(tool?.name || "").toLowerCase();
+			return requiredNameTokens.every((token) => name.includes(token));
+		});
+		const firstSelector = searchTokens[0];
+		if (firstSelector) {
+			const exactNameMatches = eligibleTools.filter((tool) => String(tool?.name || "").toLowerCase() === firstSelector);
+			if (exactNameMatches.length === 1) return exactNameMatches;
+			const exactLeafMatches = eligibleTools.filter((tool) => {
+				return String(tool?.name || "").toLowerCase().split(/__|:/).at(-1) === firstSelector;
+			});
+			if (exactLeafMatches.length === 1) return exactLeafMatches;
+		}
+		return tools.map((tool) => {
+			const name = String(tool?.name || "").toLowerCase();
+			const description = String(tool?.description || "").toLowerCase();
+			if (!requiredNameTokens.every((token) => name.includes(token))) return null;
+			if (!searchTokens.every((token) => name.includes(token) || description.includes(token))) return null;
+			return {
+				tool,
+				score: searchTokens.reduce((total, token) => total + (name.includes(token) ? 5 : 1), 0) + requiredNameTokens.length * 5
+			};
+		}).filter(Boolean).sort((left, right) => right.score - left.score || String(left.tool.name).localeCompare(String(right.tool.name))).slice(0, 5).map((entry) => entry.tool);
+	}
+	function relatedSearchTerms(token) {
+		return TOOL_SEARCH_RELATED_TERM_GROUPS.find((terms) => terms.includes(token)) || [token];
+	}
+	function rankingIntentTexts(value) {
+		const text = String(value || "");
+		const channelBodies = [...text.matchAll(/(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/giu)].map((match) => match[1]);
+		return (channelBodies.length > 0 ? channelBodies : [text]).map((intentText) => normalizeDeferredToolQuery(intentText.replace(TOOL_RANK_EMBEDDED_CONTENT_RE, " ")));
+	}
+	function rankingTokens(value) {
+		return [...new Set(String(value || "").normalize("NFKC").toLowerCase().match(/[\p{L}\p{N}]{3,}/gu) || [])].filter((token) => !TOOL_RANK_STOP_WORDS.has(token));
+	}
+	function toolRankingDocument(tool) {
+		const name = String(tool?.name || "");
+		const leaf = name.split(/__|:/).at(-1) || name;
+		const splitToolName = (value) => String(value || "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replaceAll("_", " ");
+		const nameTokens = rankingTokens(`${splitToolName(name)} ${splitToolName(leaf)}`);
+		const descriptionTokens = rankingTokens(tool?.description);
+		const parameterText = [];
+		const properties = tool?.parameters?.properties;
+		if (properties && typeof properties === "object") for (const [parameterName, definition] of Object.entries(properties)) parameterText.push(parameterName, definition?.description || "");
+		const exampleText = Array.isArray(tool?.examples) ? tool.examples.map((example) => example?.prompt || "").join(" ") : "";
+		return {
+			name,
+			nameTokens: new Set(nameTokens),
+			descriptionTokens: new Set(descriptionTokens),
+			detailTokens: new Set(rankingTokens(`${parameterText.join(" ")} ${exampleText}`))
+		};
+	}
+	function tokenMatchScore(document, token) {
+		if (document.nameTokens.has(token)) return 10;
+		if (document.descriptionTokens.has(token)) return 5;
+		if (document.detailTokens.has(token)) return 4;
+		const related = relatedSearchTerms(token).filter((term) => term !== token);
+		if (related.some((term) => document.nameTokens.has(term))) return 5;
+		if (related.some((term) => document.descriptionTokens.has(term))) return 3;
+		if (related.some((term) => document.detailTokens.has(term))) return 2;
+		return 0;
+	}
+	/**
+	* Select a tiny, high-confidence subset of deferred schemas for the current
+	* request. This mirrors AnythingLLM's tool-reranker boundary without adding an
+	* embedding runtime: King reuses the descriptions it already owns and keeps
+	* ToolSearch available whenever the lexical evidence is weak or ambiguous.
+	*/
+	function rankedToolNamesForTurnText(tools, value, options = {}) {
+		const maxTools = Math.max(0, Math.min(MAX_AUTO_RANKED_TOOLS, Number.isInteger(options.maxTools) ? options.maxTools : MAX_AUTO_RANKED_TOOLS));
+		if (maxTools === 0) return /* @__PURE__ */ new Set();
+		const queryTokens = [...new Set(rankingIntentTexts(value).flatMap(rankingTokens))];
+		if (queryTokens.length === 0) return /* @__PURE__ */ new Set();
+		const ranked = (Array.isArray(tools) ? tools : []).map((tool) => {
+			const document = toolRankingDocument(tool);
+			if (!document.name) return null;
+			let score = 0;
+			let matchedTokens = 0;
+			let exactNameMatches = 0;
+			let relatedNameMatches = 0;
+			for (const token of queryTokens) {
+				const tokenScore = tokenMatchScore(document, token);
+				if (tokenScore === 0) continue;
+				score += tokenScore;
+				matchedTokens += 1;
+				if (document.nameTokens.has(token)) exactNameMatches += 1;
+				else if (relatedSearchTerms(token).some((term) => document.nameTokens.has(term))) relatedNameMatches += 1;
+			}
+			return matchedTokens >= 2 || exactNameMatches >= 1 && score >= 10 || relatedNameMatches >= 1 && score >= 5 ? {
+				name: document.name,
+				score,
+				matchedTokens,
+				exactNameMatches
+			} : null;
+		}).filter(Boolean).sort((left, right) => right.matchedTokens - left.matchedTokens || right.score - left.score || right.exactNameMatches - left.exactNameMatches || left.name.localeCompare(right.name));
+		return new Set(ranked.slice(0, maxTools).map((entry) => entry.name));
+	}
+	function rankedSupportToolNamesForGoal(tools, goal, origin) {
+		if (origin?.kind !== "system_trigger" || origin?.name !== "goal_continuation") return /* @__PURE__ */ new Set();
+		if (goal?.status !== "active") return /* @__PURE__ */ new Set();
+		const checkpoint = goal.actionCheckpoint;
+		if (checkpoint?.phase === "wait" || checkpoint?.nextTrigger?.kind !== "immediate") return /* @__PURE__ */ new Set();
+		const supportChoice = String(checkpoint?.problemFrame?.supportChoice ?? "").trim();
+		if (!supportChoice.match(/^(?:tool|skill)\s*:\s*(.+)$/iu)?.[1]) return /* @__PURE__ */ new Set();
+		return rankedToolNamesForTurnText(tools, supportChoice, { maxTools: 1 });
+	}
+	function searchRelatedDeferredTools(tools, query, options = {}) {
+		const normalized = normalizeDeferredToolQuery(query).toLowerCase();
+		if (!normalized || normalized.startsWith("select:")) return [];
+		const tokens = normalized.split(/\s+/).filter(Boolean);
+		const requestedNameTokens = tokens.filter((token) => token.startsWith("+")).map((token) => token.slice(1)).filter(Boolean);
+		const relaxRequiredNameTokens = options.relaxRequiredNameTokens === true && requestedNameTokens.length > 0;
+		const requiredNameTokens = relaxRequiredNameTokens ? [] : requestedNameTokens;
+		const searchTokens = [...tokens.filter((token) => !token.startsWith("+")), ...relaxRequiredNameTokens ? requestedNameTokens : []].filter((token) => !TOOL_SEARCH_INTENT_WORDS.has(token));
+		if (searchTokens.length < 2 && !TOOL_SEARCH_SINGLE_TERM_RELATED_FALLBACKS.has(searchTokens[0])) return [];
+		const minimumMatchedTokens = searchTokens.length === 1 ? 1 : Math.max(2, Math.ceil(searchTokens.length * .75));
+		const ranked = tools.map((tool) => {
+			const name = String(tool?.name || "").toLowerCase();
+			const description = String(tool?.description || "").toLowerCase();
+			if (!requiredNameTokens.every((token) => name.includes(token))) return null;
+			let matchedTokens = 0;
+			let score = requiredNameTokens.length * 8;
+			for (const token of searchTokens) {
+				if (name.includes(token)) {
+					matchedTokens += 1;
+					score += 8;
+					continue;
+				}
+				if (description.includes(token)) {
+					matchedTokens += 1;
+					score += 4;
+					continue;
+				}
+				const related = relatedSearchTerms(token).filter((term) => term !== token);
+				if (related.some((term) => name.includes(term))) {
+					matchedTokens += 1;
+					score += 3;
+				} else if (related.some((term) => description.includes(term))) {
+					matchedTokens += 1;
+					score += 2;
+				}
+			}
+			return matchedTokens >= minimumMatchedTokens ? {
+				tool,
+				score,
+				matchedTokens
+			} : null;
+		}).filter(Boolean).sort((left, right) => right.matchedTokens - left.matchedTokens || right.score - left.score || String(left.tool.name).localeCompare(String(right.tool.name)));
+		if (relaxRequiredNameTokens && ranked.length > 0) {
+			const best = ranked[0];
+			return ranked.filter((entry) => entry.matchedTokens === best.matchedTokens && entry.score === best.score).slice(0, 5).map((entry) => entry.tool);
+		}
+		return ranked.slice(0, 5).map((entry) => entry.tool);
+	}
+	function rememberLoadedTool(loadedToolNames, name) {
+		loadedToolNames.delete(name);
+		loadedToolNames.add(name);
+		while (loadedToolNames.size > MAX_PERSISTENT_DEFERRED_TOOLS) loadedToolNames.delete(loadedToolNames.values().next().value);
+	}
+	function rememberDeferredToolAfterNotFound(loadedToolNames, toolName, result) {
+		if (!(loadedToolNames instanceof Set) || result?.isError !== true) return false;
+		const name = String(toolName || "").trim();
+		if (!name || String(result?.output || "").trim() !== `Tool "${name}" not found`) return false;
+		rememberLoadedTool(loadedToolNames, name);
+		return true;
+	}
+	function createDeferredToolLoader(selectedTools, deferredTools, loadedToolNames = /* @__PURE__ */ new Set()) {
+		if (!Array.isArray(selectedTools)) throw new TypeError("selectedTools must be an array");
+		if (!(loadedToolNames instanceof Set)) throw new TypeError("loadedToolNames must be a Set");
+		const available = /* @__PURE__ */ new Map();
+		for (const tool of Array.isArray(deferredTools) ? deferredTools : []) {
+			const name = String(tool?.name || "").trim();
+			if (name && !available.has(name)) available.set(name, tool);
+		}
+		const deferredCount = available.size;
+		const loader = {
+			name: DEFERRED_TOOL_LOADER_NAME,
+			description: [
+				`Search ${deferredCount} deferred ${deferredCount === 1 ? "tool schema" : "tool schemas"} without loading all definitions.`,
+				"Use select:leaf_name for one known tool, plain keywords to search, or +word to require that word in the tool name.",
+				`Loaded tools are available in the next step; the ${MAX_PERSISTENT_DEFERRED_TOOLS} most recently selected schemas remain loaded.`
+			].join("\n"),
+			parameters: {
+				type: "object",
+				properties: { query: {
+					type: "string",
+					maxLength: MAX_TOOL_SEARCH_QUERY_CHARS,
+					description: "Exact selection or keyword query, for example select:download_attachment or +slack send."
+				} },
+				required: ["query"],
+				additionalProperties: false
+			},
+			resolveExecution(args) {
+				const query = normalizeDeferredToolQuery(args?.query);
+				return {
+					description: query ? `Searching tool schemas for ${query}` : "Searching tool schemas",
+					approvalRule: DEFERRED_TOOL_LOADER_NAME,
+					execute: async () => {
+						let matches = searchDeferredTools([...available.values()], query);
+						let relatedFallback = false;
+						if (matches.length === 0) {
+							matches = searchRelatedDeferredTools([...available.values()], query);
+							relatedFallback = matches.length > 0;
+						}
+						if (matches.length === 0) {
+							matches = searchRelatedDeferredTools([...available.values()], query, { relaxRequiredNameTokens: true });
+							relatedFallback = matches.length > 0;
+						}
+						if (matches.length === 0) {
+							const alreadyLoaded = query.toLowerCase().startsWith("select:") ? searchDeferredTools(selectedTools.filter((tool) => tool?.name !== DEFERRED_TOOL_LOADER_NAME), query) : [];
+							if (alreadyLoaded.length === 1) return {
+								isError: false,
+								output: `Tool schema already loaded: ${alreadyLoaded[0].name}. Invoke it now.`
+							};
+							return {
+								isError: false,
+								output: [
+									`No eligible deferred tool is available for: ${query || "[empty query]"}.`,
+									"Use a loaded alternative or report this integration as unavailable.",
+									"ToolSearch remains available for a different tool needed later."
+								].join(" ")
+							};
+						}
+						if (query.toLowerCase().startsWith("select:") && matches.length !== 1) return {
+							isError: true,
+							output: `Tool selection is ambiguous: ${matches.map((tool) => tool.name).join(", ")}`
+						};
+						const loaded = [];
+						for (const tool of matches) {
+							const name = String(tool.name);
+							if (!selectedTools.some((candidate) => candidate?.name === name)) selectedTools.push(tool);
+							rememberLoadedTool(loadedToolNames, name);
+							loaded.push(name);
+						}
+						return {
+							isError: false,
+							output: `${relatedFallback ? "Loaded related tool schemas" : "Loaded tool schemas"}: ${loaded.join(", ")}. Invoke them in the next step.`
+						};
+					}
+				};
+			}
+		};
+		deferredToolLoaders.add(loader);
+		return loader;
+	}
+	module.exports = {
+		isDeferredToolLoader: (tool) => deferredToolLoaders.has(tool),
+		CORE_TOOL_NAMES,
+		DEFERRED_TOOL_LOADER_NAME,
+		MAX_PERSISTENT_DEFERRED_TOOLS,
+		MAX_AUTO_RANKED_TOOLS,
+		MAX_TOOL_SEARCH_QUERY_CHARS,
+		TOOL_SCHEMA_BUDGET_RATIO,
+		TOOL_SCHEMA_MAX_TOKENS,
+		createDeferredToolLoader,
+		deferredToolCatalog,
+		deferredToolNames,
+		mediaGenerationToolNamesForText,
+		mediaToolNamesForTurnText,
+		normalizeDeferredToolQuery,
+		rankedSupportToolNamesForGoal,
+		rankedToolNamesForTurnText,
+		rememberDeferredToolAfterNotFound,
+		toolSchemaBudgetTokens
+	};
+}));
+//#endregion
 //#region ../../packages/agent-core/src/agent/permission/policies/default-tool-approve.ts
-var DEFAULT_APPROVE_TOOLS, DefaultToolApprovePermissionPolicy;
+var import_turn_tool_performance_policy$1, DEFAULT_APPROVE_TOOLS, DefaultToolApprovePermissionPolicy;
 var init_default_tool_approve = __esmMin((() => {
+	import_turn_tool_performance_policy$1 = require_turn_tool_performance_policy();
 	DEFAULT_APPROVE_TOOLS = new Set([
 		"Read",
 		"Grep",
@@ -238605,7 +239121,7 @@ var init_default_tool_approve = __esmMin((() => {
 	DefaultToolApprovePermissionPolicy = class {
 		name = "default-tool-approve";
 		evaluate(context) {
-			if (!DEFAULT_APPROVE_TOOLS.has(context.toolCall.name)) return;
+			if (!DEFAULT_APPROVE_TOOLS.has(context.toolCall.name) && !(0, import_turn_tool_performance_policy$1.isDeferredToolLoader)(context.tool)) return;
 			return { kind: "approve" };
 		}
 	};
@@ -240440,6 +240956,43 @@ var init_scanner = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/agent-core/src/skill/registry.ts
+function compactLegacyModelSkillListing(prompt, registry) {
+	const header = "DISREGARD any earlier skill listings. Current available skills:";
+	if (!prompt.includes(header)) return prompt;
+	const listing = renderGroupedSkills(registry.listInvocableSkills().filter((skill) => skill.metadata.isSubSkill !== true), formatModelSkill);
+	if (listing.length <= MODEL_SKILL_LISTING_MAX_CHARS) return prompt;
+	const legacy = `${header}\n${listing}`;
+	const start = prompt.indexOf(legacy);
+	if (start < 0) return prompt;
+	const end = start + legacy.length;
+	if (end < prompt.length && !prompt.startsWith("\n\n", end)) return prompt;
+	return prompt.slice(0, start) + registry.getModelSkillListing() + prompt.slice(end);
+}
+function searchModelSkills(skills, query, offset = 0) {
+	const normalize = (value) => value.normalize("NFKC").toLowerCase();
+	const words = normalize(query.slice(0, 1e3)).match(/[\p{L}\p{N}_-]+/gu) ?? [];
+	const matches = skills.filter((skill) => skill.metadata.disableModelInvocation !== true && skill.metadata.isSubSkill !== true && isInlineSkillType(skill.metadata.type)).map((skill) => {
+		const name = normalize(skill.name);
+		const metadata = normalize(`${skill.name} ${skill.description} ${skill.metadata.whenToUse ?? ""}`);
+		return {
+			skill,
+			matches: words.every((word) => metadata.includes(word)),
+			score: words.filter((word) => name.includes(word)).length
+		};
+	}).filter((item) => item.matches).sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name));
+	const start = Number.isSafeInteger(offset) && offset >= 0 ? offset : 0;
+	const page = matches.slice(start, start + 10);
+	return JSON.stringify({
+		total: matches.length,
+		offset: start,
+		nextOffset: start + page.length < matches.length ? start + page.length : null,
+		matches: page.map(({ skill }) => ({
+			name: skill.name,
+			description: truncate$2(skill.description, LISTING_DESC_MAX),
+			path: skill.path
+		}))
+	});
+}
 function pluginSkillKey(pluginId, skillName) {
 	return `${pluginId}\0${normalizeSkillName(skillName)}`;
 }
@@ -240477,13 +241030,14 @@ function truncate$2(value, max) {
 	}
 	return `${result}…`;
 }
-var LISTING_DESC_MAX, SessionSkillRegistry, SOURCE_GROUPS, graphemeSegmenter$2;
+var LISTING_DESC_MAX, MODEL_SKILL_LISTING_MAX_CHARS, SessionSkillRegistry, SOURCE_GROUPS, graphemeSegmenter$2;
 var init_registry = __esmMin((() => {
 	init_parser$1();
 	init_scanner();
 	init_types$15();
 	init_xml_escape();
 	LISTING_DESC_MAX = 250;
+	MODEL_SKILL_LISTING_MAX_CHARS = 8e3;
 	SessionSkillRegistry = class {
 		byName = /* @__PURE__ */ new Map();
 		byPluginAndName = /* @__PURE__ */ new Map();
@@ -240563,6 +241117,17 @@ var init_registry = __esmMin((() => {
 		getModelSkillListing() {
 			const lines = ["DISREGARD any earlier skill listings. Current available skills:"];
 			const listing = renderGroupedSkills(this.listInvocableSkills().filter((skill) => skill.metadata.isSubSkill !== true), formatModelSkill);
+			if (listing.length > MODEL_SKILL_LISTING_MAX_CHARS) {
+				const count = this.listInvocableSkills().filter((skill) => skill.metadata.isSubSkill !== true).length;
+				return [
+					lines[0],
+					`${count} skills are available on demand.`,
+					"Before specialized work, search descriptions with Skill({skill: \"task keywords\", search: true}).",
+					"Search returns names and metadata only. Invoke Skill({skill: \"exact-name\", args: \"...\"}) to load instructions.",
+					"Use an empty search string to browse; follow nextOffset with offset to see more results.",
+					"A search miss is not proof that no skill exists; try its exact name or browse the catalog."
+				].join("\n");
+			}
 			if (listing.length > 0) lines.push(listing);
 			return lines.length === 1 ? "" : lines.join("\n");
 		}
@@ -256945,7 +257510,7 @@ human_shell_hint: The pending question is also visible in /tasks.`,
 //#region ../../packages/agent-core/src/tools/builtin/collaboration/skill-tool.md?raw
 var skill_tool_default;
 var init_skill_tool$1 = __esmMin((() => {
-	skill_tool_default = "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do not re-invoke a skill to repeat work already done: if a `<blun-skill-loaded>` block for it with the same `args` is already present in the conversation, follow those instructions directly instead of calling the tool again. Do call the tool again when you need the skill with different arguments — the loaded block was expanded with the earlier `args` and will not reflect new inputs.\n\nAUTO-SKILL-ROUTING — you MUST proactively use skills WITHOUT being asked:\n- Before responding to any user request, check if an available skill matches the task. If it does, call this tool FIRST — do not attempt the task without the skill.\n- Images/screenshots → use the image/vision skill (e.g. \"screenshot-lesen\") to read and understand the image content before responding.\n- Design/UI tasks → use the appropriate design skill (e.g. \"design-taste-frontend\", \"high-end-visual-design\", \"apple-design\", \"huashu-design\", \"emil-design-eng\", \"motion-design-taste\", \"stitch-design-taste\", \"minimalist-ui\", \"industrial-brutalist-ui\", \"redesign-existing-projects\").\n- FOR ANY UI/frontend/visual output you MUST first load a design skill — never produce raw/default-styled UI. Gradients-everywhere, random emoji-icons, generic AI-looking layouts = FORBIDDEN slop. Always use a design skill before writing UI code.\n- Video/media tasks → use \"ffmpeg\" or the relevant media skill.\n- Web scraping/reading → use \"web-lesen\".\n- PDF/document tasks → use the PDF or document skill.\n- When in doubt whether a skill applies, call it — using a skill when not needed is harmless; NOT using a skill when it would help is a failure.\n- Never tell the user \"I don't have the right tool\" if a matching skill exists in the listing — use it.\n- This is automatic: do not ask the user \"should I use a skill?\" — just use it.\n";
+	skill_tool_default = "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do not re-invoke a skill to repeat work already done: if a `<blun-skill-loaded>` block for it with the same `args` is already present in the conversation, follow those instructions directly instead of calling the tool again. Do call the tool again when you need the skill with different arguments — the loaded block was expanded with the earlier `args` and will not reflect new inputs.\n\nFor a deferred catalog, call `Skill({skill: \"task keywords\", search: true})` first. Search returns at most 10 eligible names and descriptions without loading skill instructions. An empty search browses the catalog; pass `nextOffset` as `offset` for the next page. Then invoke the chosen exact name with `search` omitted.\n\nAUTO-SKILL-ROUTING — you MUST proactively use skills WITHOUT being asked:\n- Before responding to any user request, check if an available skill matches the task. If it does, call this tool FIRST — do not attempt the task without the skill.\n- Images/screenshots → use the image/vision skill (e.g. \"screenshot-lesen\") to read and understand the image content before responding.\n- Design/UI tasks → use the appropriate design skill (e.g. \"design-taste-frontend\", \"high-end-visual-design\", \"apple-design\", \"huashu-design\", \"emil-design-eng\", \"motion-design-taste\", \"stitch-design-taste\", \"minimalist-ui\", \"industrial-brutalist-ui\", \"redesign-existing-projects\").\n- FOR ANY UI/frontend/visual output you MUST first load a design skill — never produce raw/default-styled UI. Gradients-everywhere, random emoji-icons, generic AI-looking layouts = FORBIDDEN slop. Always use a design skill before writing UI code.\n- Video/media tasks → use \"ffmpeg\" or the relevant media skill.\n- Web scraping/reading → use \"web-lesen\".\n- PDF/document tasks → use the PDF or document skill.\n- When in doubt whether a skill applies, call it — using a skill when not needed is harmless; NOT using a skill when it would help is a failure.\n- Never tell the user \"I don't have the right tool\" if a matching skill exists in the listing — use it.\n- This is automatic: do not ask the user \"should I use a skill?\" — just use it.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/collaboration/skill-tool.ts
@@ -257001,7 +257566,9 @@ var init_skill_tool = __esmMin((() => {
 	};
 	SkillToolInputSchema = object$1({
 		skill: string().describe("The exact name of the skill to invoke, spelled as it appears in the current skill listing (e.g. \"commit\", \"pdf\")."),
-		args: string().optional().describe("Optional argument string for the skill, written like a command line (e.g. `-m \"fix bug\"`, `123`, a file path). It is split on whitespace (quotes group a token) and expanded into the skill's placeholders ($NAME, $1, $ARGUMENTS); if the skill body has no placeholders, the whole string is still appended as a trailing `ARGUMENTS:` line. Omit it only when there is nothing to pass.")
+		args: string().optional().describe("Optional argument string for the skill, written like a command line (e.g. `-m \"fix bug\"`, `123`, a file path). It is split on whitespace (quotes group a token) and expanded into the skill's placeholders ($NAME, $1, $ARGUMENTS); if the skill body has no placeholders, the whole string is still appended as a trailing `ARGUMENTS:` line. Omit it only when there is nothing to pass."),
+		search: boolean$1().optional().describe("Search eligible skill metadata using skill as keywords, without activating a skill."),
+		offset: number$1().int().min(0).optional().describe("For search only: nextOffset from a previous page. Each page has at most 10 skills.")
 	});
 	SkillTool = class SkillTool {
 		agent;
@@ -257014,6 +257581,12 @@ var init_skill_tool = __esmMin((() => {
 			this.options = options;
 		}
 		resolveExecution(args) {
+			if (args.search === true) return {
+				description: `Search skill metadata: ${args.skill}`,
+				approvalRule: this.name,
+				matchesRule: (ruleArgs) => matchesGlobRuleSubject(ruleArgs, args.skill),
+				execute: async () => ({ output: searchModelSkills(this.agent.skills?.registry.listInvocableSkills() ?? [], args.skill, args.offset) })
+			};
 			return {
 				description: `Invoke skill ${args.skill}`,
 				display: {
@@ -264616,22 +265189,45 @@ function blunThinkingIntentInput(input) {
 		text: channelText
 	}];
 }
+function blunTurnHasAttachment(input) {
+	return input.some((part) => part.type !== "text") || /\b(?:image_path|attachment_file_id)\s*=/i.test(blunExtractText(input));
+}
+function greetingHistory(history, anchor) {
+	const start = anchor === void 0 ? -1 : history.indexOf(anchor);
+	if (start < 0) return history;
+	const recent = [];
+	let chars = 0;
+	for (let i = start - 1; i >= 0 && recent.length < 6; i -= 1) {
+		const message = history[i];
+		if (message.role === "tool" || message.toolCalls.length > 0) break;
+		if (message.role !== "assistant" && message.origin?.kind !== "user") continue;
+		const size = blunExtractText(message.content).length;
+		if (chars + size > 12e3 || message.content.some((part) => part.type !== "text")) break;
+		recent.unshift(message);
+		chars += size;
+	}
+	while (recent.length > 0 && recent[0].role !== "user") recent.shift();
+	return [...recent, ...history.slice(start)];
+}
 function blunToolsForOrigin(tools, origin) {
 	if (origin.kind !== "system_trigger" && origin.kind !== "injection") return tools;
 	return tools.filter((tool) => !BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name));
 }
 /**
-* Choose the tool set for a task turn. Returns the full set unless the model
-* window is small enough that the schemas alone blow the context budget, in
-* which case the lean essential set is used. Never returns an empty list when
-* tools were requested: a profile with no lean-set matches keeps the full set
-* rather than sending a tool-less task turn.
+* Restore bounded schema disclosure even on large-context models. Only tools
+* already eligible for this turn enter the loader; execution still follows
+* the ordinary permission pipeline.
 */
-function blunSelectTurnTools(tools, maxContextTokens) {
-	if (maxContextTokens === void 0 || maxContextTokens <= 0) return tools;
-	if (estimateTokensForTools(tools) <= maxContextTokens * BLUN_TOOL_BUDGET_RATIO) return tools;
-	const lean = tools.filter((tool) => BLUN_LEAN_TOOL_NAMES.has(tool.name) || BLUN_LEAN_KEEP_RE.test(tool.name) || BLUN_LANGUAGE_REVIEW_TOOL_NAMES.has(tool.name));
-	return lean.length > 0 ? lean : tools;
+function blunSelectTurnTools(tools, maxContextTokens, loadedToolNames = /* @__PURE__ */ new Set(), requiredToolNames = /* @__PURE__ */ new Set(), selected = []) {
+	if (estimateTokensForTools(tools) <= (0, import_turn_tool_performance_policy.toolSchemaBudgetTokens)(maxContextTokens) || tools.some((tool) => tool.name === "ToolSearch")) {
+		selected.splice(0, selected.length, ...tools);
+		return selected;
+	}
+	selected.splice(0, selected.length, ...tools.filter((tool) => BLUN_LEAN_TOOL_NAMES.has(tool.name) || BLUN_LEAN_KEEP_RE.test(tool.name) || BLUN_LANGUAGE_REVIEW_TOOL_NAMES.has(tool.name) || loadedToolNames.has(tool.name) || requiredToolNames.has(tool.name)));
+	const names = new Set(selected.map((tool) => tool.name));
+	const deferred = tools.filter((tool) => !names.has(tool.name));
+	if (deferred.length > 0) selected.push((0, import_turn_tool_performance_policy.createDeferredToolLoader)(selected, deferred, loadedToolNames));
+	return selected;
 }
 function goalContinuationOrigin(origin) {
 	const cronRunId = origin.kind === "cron_job" ? origin.runId : origin.kind === "system_trigger" && origin.name === "goal_continuation" ? origin.cronRunId : void 0;
@@ -264874,7 +265470,7 @@ function toolResultText(result) {
 function abandonedToolResultOutput(ended) {
 	return `Tool call did not complete: ${ended.reason === "cancelled" ? "the turn was cancelled" : ended.reason === "failed" ? `the turn failed${ended.error !== void 0 ? ` (${ended.error.message})` : ""}` : "the turn ended"} before its result was recorded. Do not assume the tool completed successfully.`;
 }
-var BLUN_LEAN_TOOL_NAMES, BLUN_LANGUAGE_REVIEW_TOOL_NAMES, BLUN_LEAN_KEEP_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TOOL_BUDGET_RATIO, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
+var import_turn_tool_performance_policy, BLUN_LEAN_TOOL_NAMES, BLUN_LANGUAGE_REVIEW_TOOL_NAMES, BLUN_LEAN_KEEP_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
 var init_turn = __esmMin((() => {
 	init_dist$4();
 	init_src$4();
@@ -264892,14 +265488,17 @@ var init_turn = __esmMin((() => {
 	init_tool_dedup();
 	init_tool_result_budget();
 	init_response_review();
+	import_turn_tool_performance_policy = require_turn_tool_performance_policy();
 	BLUN_LEAN_TOOL_NAMES = new Set([
 		"Read",
+		"ReadBatch",
 		"Write",
 		"Edit",
 		"Grep",
 		"Glob",
 		"Bash",
 		"TodoList",
+		"Skill",
 		"CompactConversation",
 		"MistakeRecord"
 	]);
@@ -264911,7 +265510,6 @@ var init_turn = __esmMin((() => {
 	].map((name) => qualifyMcpToolName("blun-language-guard", name)));
 	BLUN_LEAN_KEEP_RE = /(^|__|:)(reply|react|edit_message|download_attachment|memory_(?:status|settings_update|remember|list|threads_list|recall))$/i;
 	BLUN_TELEGRAM_OUTBOUND_TOOL_RE = /^mcp__[^\s]*telegram[^\s]*__(?:reply|react|edit_message)$/i;
-	BLUN_TOOL_BUDGET_RATIO = .25;
 	LLM_NOT_SET_MESSAGE = "LLM not set, send \"/login\" to login";
 	GOAL_CONTINUATION_ORIGIN = {
 		kind: "system_trigger",
@@ -264954,6 +265552,8 @@ var init_turn = __esmMin((() => {
 	TurnFlow = class {
 		agent;
 		admissionClosed = false;
+		loadedToolNames = /* @__PURE__ */ new Set();
+		refreshSelectedTools;
 		executions = new ExecutionLedger();
 		executingControllers = /* @__PURE__ */ new Set();
 		steerBuffer = [];
@@ -265190,6 +265790,9 @@ var init_turn = __esmMin((() => {
 			if (snapshot.throughSequence < 0) return false;
 			return this.flushSteerBuffer(turnId, snapshot.throughSequence);
 		}
+		refreshRequestTools(snapshot) {
+			return this.refreshSelectedTools?.(snapshot);
+		}
 		bufferSteer(input, origin, targetTurnId) {
 			this.steerBuffer.push({
 				sequence: this.nextSteerSequence,
@@ -265573,17 +266176,41 @@ var init_turn = __esmMin((() => {
 			const personalMemoryRecall = await this.agent.injection.injectPersonalMemoryForTurn(turnId, input, origin, signal);
 			await this.agent.injection.injectGoal();
 			this.setActiveSteerAcceptance(turnId, true);
-			const turnNeedsTools = blunTurnNeedsTools(input, origin);
 			const turnNeedsThinking = blunTurnNeedsTools(blunThinkingIntentInput(input), origin);
+			let toolInput = input;
+			let taskToolsNeeded = turnNeedsThinking || blunTurnHasAttachment(input);
+			const greetingAnchor = this.agent.context.history.findLast((message) => message.role === "user" && message.origin?.kind === "user");
+			let partialContext = false;
+			const turnHistory = () => {
+				const history = personalMemoryRecall === void 0 ? this.agent.context.history : [...this.agent.context.history, personalMemoryRecall];
+				const selected = taskToolsNeeded ? history : greetingHistory(history, greetingAnchor);
+				partialContext = selected.length < history.length;
+				return selected;
+			};
 			const turnLLM = this.agent.llmForTurn(turnNeedsThinking ? void 0 : "off");
+			const turnTools = this.agent.tools.captureTurnTools();
 			while (true) {
 				signal.throwIfAborted();
 				const model = this.agent.config.model;
 				const loopControl = this.agent.blunConfig?.loopControl;
 				let stopForGoalBudget = false;
 				try {
-					const eligibleTools = blunToolsForOrigin(this.agent.injection.filterPersonalMemoryToolsForTurn(turnId, input, origin, this.agent.tools.loopTools), origin);
-					const selectedTools = turnNeedsTools ? blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens) : eligibleTools.filter((tool) => BLUN_LANGUAGE_REVIEW_TOOL_NAMES.has(tool.name));
+					const selectedTools = [];
+					this.refreshSelectedTools = (snapshot) => {
+						if (snapshot.messages.length > 0) toolInput = snapshot.messages.flatMap((message) => message.content);
+						const eligibleTools = blunToolsForOrigin(this.agent.injection.filterPersonalMemoryToolsForTurn(turnId, input, origin, turnTools()), origin);
+						const intent = blunThinkingIntentInput(toolInput);
+						taskToolsNeeded ||= blunTurnNeedsTools(intent, origin) || blunTurnHasAttachment(toolInput);
+						const required = (0, import_turn_tool_performance_policy.mediaToolNamesForTurnText)(blunExtractText(toolInput));
+						if (taskToolsNeeded) {
+							blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, required, selectedTools);
+							for (const name of (0, import_turn_tool_performance_policy.rankedToolNamesForTurnText)(eligibleTools, blunExtractText(intent))) {
+								const tool = eligibleTools.find((candidate) => candidate.name === name);
+								if (tool !== void 0 && !selectedTools.some((candidate) => candidate.name === name) && estimateTokensForTools([...selectedTools, tool]) <= (0, import_turn_tool_performance_policy.toolSchemaBudgetTokens)(this.agent.config.modelCapabilities?.max_context_tokens)) selectedTools.push(tool);
+							}
+						} else selectedTools.splice(0, selectedTools.length, ...eligibleTools.filter((tool) => BLUN_LANGUAGE_REVIEW_TOOL_NAMES.has(tool.name) || BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name)));
+						return selectedTools;
+					};
 					return (await runTurn({
 						turnId: String(turnId),
 						signal,
@@ -265594,15 +266221,15 @@ var init_turn = __esmMin((() => {
 							}, completion);
 						},
 						llm: turnLLM,
-						buildMessages: () => this.agent.context.project(personalMemoryRecall === void 0 ? this.agent.context.history : [...this.agent.context.history, personalMemoryRecall], { dropOrphanResults: true }),
-						buildMessagesStrict: () => this.agent.context.project(personalMemoryRecall === void 0 ? this.agent.context.history : [...this.agent.context.history, personalMemoryRecall], {
+						buildMessages: () => this.agent.context.project(turnHistory(), { dropOrphanResults: true }),
+						buildMessagesStrict: () => this.agent.context.project(turnHistory(), {
 							synthesizeMissing: true,
 							dropOrphanResults: true,
 							dedupeDuplicateToolCalls: true,
 							dropLeadingNonUser: true,
 							mergeConsecutiveAssistants: true
 						}),
-						dispatchEvent: this.buildDispatchEvent(turnId, signal, onFinalResponse),
+						dispatchEvent: this.buildDispatchEvent(turnId, signal, onFinalResponse, () => partialContext),
 						tools: selectedTools,
 						log: this.agent.log,
 						maxSteps: loopControl?.maxStepsPerTurn,
@@ -265719,6 +266346,8 @@ var init_turn = __esmMin((() => {
 						error
 					});
 					throw error;
+				} finally {
+					this.refreshSelectedTools = void 0;
 				}
 			}
 		}
@@ -265739,13 +266368,16 @@ var init_turn = __esmMin((() => {
 				this.agent.log.warn("failed to close abandoned tool exchange", { error });
 			}
 		}
-		buildDispatchEvent(turnId, signal, onFinalResponse) {
+		buildDispatchEvent(turnId, signal, onFinalResponse, usesPartialContext) {
 			let responseStepUuid;
 			let responseParts = [];
 			let responseHasToolCall = false;
 			const dispatch = createLoopEventDispatcher({
 				appendTranscriptRecord: async (event) => {
-					this.agent.context.appendLoopEvent(event);
+					this.agent.context.appendLoopEvent(event.type === "step.end" && usesPartialContext?.() ? {
+						...event,
+						contextCoverage: "partial"
+					} : event);
 				},
 				emitLiveEvent: (event) => {
 					this.agent.cron?.observeLoopEvent(turnId, event);
@@ -268617,6 +269249,17 @@ var init_tool$1 = __esmMin((() => {
 			const names = uniq([...this.enabledTools, ...mcpNames]).toSorted((a, b) => a.localeCompare(b)).filter((name) => !(hideGoalMutationTools && (name === "SetGoalBudget" || name === "UpdateGoal")));
 			return (allowedTools !== void 0 && allowedTools.length > 0 ? names.filter((name) => allowedTools.includes(name)) : names).map((name) => this.userTools.get(name) ?? this.mcpTools.get(name)?.tool ?? this.builtinTools.get(name)).filter((tool) => !!tool);
 		}
+		captureTurnTools() {
+			if (this.loopToolsOverride !== void 0) {
+				const tools = this.loopToolsOverride;
+				return () => tools;
+			}
+			const fixed = this.loopTools.filter((tool) => this.mcpTools.get(tool.name)?.tool !== tool);
+			const fixedNames = new Set(fixed.map((tool) => tool.name));
+			const patterns = [...this.mcpAccessPatterns];
+			const allowed = this.allowedTools === void 0 ? void 0 : new Set(this.allowedTools);
+			return () => [...fixed, ...[...this.mcpTools.entries()].filter(([name]) => !fixedNames.has(name) && patterns.some((pattern) => import_picomatch.default.isMatch(name, pattern)) && (allowed === void 0 || allowed.has(name))).map(([, entry]) => entry.tool)].toSorted((a, b) => a.name.localeCompare(b.name));
+		}
 	};
 }));
 //#endregion
@@ -269276,6 +269919,7 @@ var init_agent = __esmMin((() => {
 	init_records();
 	init_replay();
 	init_skill$3();
+	init_registry();
 	init_swarm();
 	init_tool$1();
 	init_turn();
@@ -269476,6 +270120,12 @@ var init_agent = __esmMin((() => {
 				this.setActiveResponderModel(alias);
 			}, async (_candidate, params, rebuildMessages) => {
 				const steers = this.turn.snapshotPendingSteers();
+				const requestTools = this.turn.refreshRequestTools(steers) ?? params.tools;
+				params = {
+					...params,
+					tools: requestTools,
+					messages: await rebuildMessages()
+				};
 				let systemPrompt = this.effectiveSystemPrompt;
 				const compacted = await this.fullCompaction.beforeStep(params.signal, {
 					messages: params.messages,
@@ -269515,7 +270165,7 @@ var init_agent = __esmMin((() => {
 				capability: runtimeModel.modelCapabilities,
 				generate: this.generateForModel(modelAlias),
 				completionBudgetConfig,
-				reportedContextTokens: () => this.context.tokenCount,
+				reportedContextTokens: () => this.context.tokenCountWithPending,
 				idleTimeoutMs: this.blunConfig?.timeout ? this.blunConfig.timeout * 1e3 : void 0,
 				onMediaDropped: this.onMediaDropped,
 				visionReader: this.visionReader,
@@ -269536,7 +270186,8 @@ var init_agent = __esmMin((() => {
 			this.emitStatusUpdated();
 		}
 		get effectiveSystemPrompt() {
-			const base = this.config.systemPrompt;
+			const registry = this.skills?.registry;
+			const base = registry === void 0 ? this.config.systemPrompt : compactLegacyModelSkillListing(this.config.systemPrompt, registry);
 			if (this.runtimeSystemPromptAppend.length === 0) return base;
 			return base.length === 0 ? this.runtimeSystemPromptAppend : `${base}\n\n${this.runtimeSystemPromptAppend}`;
 		}