blun-king-cli 9.1.594 → 9.1.596

package/worker-host.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:410be0cd699a00876404e3f2e9a6d091b2c2fa9c4bb1f483b7fbdd3480a39fb2
+// BLUN_BUILD_INPUT_SHA256:2c4b3f451c41d328bb5eb43ffb226f0f3b0c458270217cecb6e1ffc63287e8bd
 import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
@@ -233816,10 +233816,11 @@ var ContextMemory = class {
 					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;
 				}
@@ -237788,6 +237789,518 @@ var AutoModeAskUserQuestionDenyPermissionPolicy = class {
 };
 //#endregion
 //#region ../../packages/agent-core/src/agent/permission/policies/default-tool-approve.ts
+var import_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
+	};
+})))();
 const DEFAULT_APPROVE_TOOLS = new Set([
 	"Read",
 	"Grep",
@@ -237810,7 +238323,7 @@ const DEFAULT_APPROVE_TOOLS = new Set([
 var 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.isDeferredToolLoader)(context.tool)) return;
 		return { kind: "approve" };
 	}
 };
@@ -239495,6 +240008,7 @@ function isWithin$1(child, parent) {
 //#endregion
 //#region ../../packages/agent-core/src/skill/registry.ts
 const LISTING_DESC_MAX = 250;
+const MODEL_SKILL_LISTING_MAX_CHARS = 8e3;
 var SessionSkillRegistry = class {
 	byName = /* @__PURE__ */ new Map();
 	byPluginAndName = /* @__PURE__ */ new Map();
@@ -239574,10 +240088,58 @@ var SessionSkillRegistry = class {
 	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");
 	}
 };
+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(skill.description, LISTING_DESC_MAX),
+			path: skill.path
+		}))
+	});
+}
 function pluginSkillKey(pluginId, skillName) {
 	return `${pluginId}\0${normalizeSkillName(skillName)}`;
 }
@@ -256149,7 +256711,7 @@ function isQuestionResponse(result) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/collaboration/skill-tool.md?raw
-var 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";
+var 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";
 var NestedSkillTooDeepError = class extends Error {
 	skillName;
 	depth;
@@ -256163,7 +256725,9 @@ var NestedSkillTooDeepError = class extends Error {
 };
 const SkillToolInputSchema = object({
 	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.")
 });
 var SkillTool = class SkillTool {
 	agent;
@@ -256176,6 +256740,12 @@ var SkillTool = class SkillTool {
 		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: {
@@ -263653,6 +264223,26 @@ 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)];
+}
 /**
 * BLUN: builtin tools kept when the full schema set would overflow a small
 * context window. The essential read / edit / run / track loop — enough for
@@ -263663,12 +264253,14 @@ function blunThinkingIntentInput(input) {
 */
 const BLUN_LEAN_TOOL_NAMES = new Set([
 	"Read",
+	"ReadBatch",
 	"Write",
 	"Edit",
 	"Grep",
 	"Glob",
 	"Bash",
 	"TodoList",
+	"Skill",
 	"CompactConversation",
 	"MistakeRecord"
 ]);
@@ -263694,25 +264286,20 @@ function blunToolsForOrigin(tools, origin) {
 	return tools.filter((tool) => !BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name));
 }
 /**
-* When the full tool schemas would consume more than this fraction of the model
-* context window, drop to {@link BLUN_LEAN_TOOL_NAMES}. Big-window cloud models
-* (their schemas are a rounding error) keep the full set; only small local
-* models (King) fall back — so the guard is self-tuning and never touches a
-* config where tools comfortably fit.
-*/
-const BLUN_TOOL_BUDGET_RATIO = .25;
-/**
-* 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;
 }
 const LLM_NOT_SET_MESSAGE = "LLM not set, send \"/login\" to login";
 /** Origin tag for the synthetic "continue" prompt that drives each goal turn. */
@@ -263770,6 +264357,8 @@ const GOAL_CONTINUATION_PROMPT = [
 var TurnFlow = class {
 	agent;
 	admissionClosed = false;
+	loadedToolNames = /* @__PURE__ */ new Set();
+	refreshSelectedTools;
 	executions = new ExecutionLedger();
 	executingControllers = /* @__PURE__ */ new Set();
 	steerBuffer = [];
@@ -264006,6 +264595,9 @@ var TurnFlow = class {
 		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,
@@ -264389,17 +264981,41 @@ var TurnFlow = class {
 		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,
@@ -264410,15 +265026,15 @@ var TurnFlow = class {
 						}, 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,
@@ -264535,6 +265151,8 @@ var TurnFlow = class {
 					error
 				});
 				throw error;
+			} finally {
+				this.refreshSelectedTools = void 0;
 			}
 		}
 	}
@@ -264555,13 +265173,16 @@ var TurnFlow = class {
 			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);
@@ -267507,6 +268128,17 @@ var ToolManager = class {
 		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
 //#region ../../packages/agent-core/src/agent/response-review-mcp.ts
@@ -268301,6 +268933,12 @@ var Agent$1 = class {
 			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,
@@ -268340,7 +268978,7 @@ var Agent$1 = class {
 			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,
@@ -268361,7 +268999,8 @@ var Agent$1 = class {
 		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}`;
 	}