blun-king-cli 9.1.394 → 9.1.396

package/LIESMICH.txt

@@ -364,6 +364,23 @@ Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
 verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
 die Medienerzeugung sei nicht verfügbar.
 
+Passende Werkzeuge ohne Such-Zwischenschritt
+---------------------------------------------
+
+Ab BLUN King 9.1.396 vergleicht King die aktuelle Anfrage mit den bereits
+registrierten Werkzeugbeschreibungen. Bei eindeutiger Übereinstimmung lädt er
+für diesen Zug höchstens zwei passende, sonst zurückgestellte Schemata direkt.
+Name, Beschreibung, Parameterhinweise und Beispiele dürfen zur Auswahl
+beitragen; frühere Nachrichten außerhalb des aktuellen Telegram-Kanalblocks
+zählen nicht als neue Absicht.
+
+ToolSearch bleibt für unklare, unbekannte und mehrdeutige Anfragen vollständig
+verfügbar. Eine automatische Auswahl wird nicht dauerhaft gespeichert und
+vergrößert den residenten Werkzeugsatz nicht. Dadurch kann eine natürliche
+Anweisung wie "Zeig mir den letzten Telegram-Verlauf" das passende Werkzeug im
+selben Modellschritt erhalten, während Begrüßungen und fachfremde Anfragen keine
+zusätzlichen Schemata laden.
+
 Angehängte Bilder werden weiterhin mit ReadMediaFile gelesen. Bild-, Video- und
 Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. GenerateVideo kann außerdem einen abgeschlossenen Bildauftrag

package/README.md

@@ -375,6 +375,22 @@ Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
 verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
 die Medienerzeugung sei nicht verfügbar.
 
+## Passende Werkzeuge ohne Such-Zwischenschritt
+
+Ab BLUN King 9.1.396 vergleicht King die aktuelle Anfrage mit den bereits
+registrierten Werkzeugbeschreibungen. Bei eindeutiger Übereinstimmung lädt er
+für diesen Zug höchstens zwei passende, sonst zurückgestellte Schemata direkt.
+Name, Beschreibung, Parameterhinweise und Beispiele dürfen zur Auswahl
+beitragen; frühere Nachrichten außerhalb des aktuellen Telegram-Kanalblocks
+zählen nicht als neue Absicht.
+
+`ToolSearch` bleibt für unklare, unbekannte und mehrdeutige Anfragen vollständig
+verfügbar. Eine automatische Auswahl wird nicht dauerhaft gespeichert und
+vergrößert den residenten Werkzeugsatz nicht. Dadurch kann eine natürliche
+Anweisung wie „Zeig mir den letzten Telegram-Verlauf“ das passende Werkzeug im
+selben Modellschritt erhalten, während Begrüßungen und fachfremde Anfragen keine
+zusätzlichen Schemata laden.
+
 Angehängte Bilder werden weiterhin mit `ReadMediaFile` gelesen. Bild-, Video-
 und Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. `GenerateVideo` kann außerdem einen abgeschlossenen Bildauftrag

package/bin/media-auto-retrieval-policy.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+const TERMINAL_FAILURES = new Set(['blocked', 'cancelled', 'canceled', 'expired', 'failed']);
+
+function parseAcceptedMediaJob(output) {
+  if (typeof output !== 'string') return undefined;
+  return /\bMedia job ([A-Za-z0-9_-]{1,200}) accepted with status\b/u.exec(output)?.[1];
+}
+
+function createMediaAutoRetrievalController(options) {
+  const active = new Map();
+  const completed = new Set();
+  const inflight = new Set();
+  const pollIntervalMs = Math.max(1, options.pollIntervalMs ?? 5000);
+  const schedule = options.schedule ?? ((fn, delay) => setTimeout(fn, delay));
+  const cancel = options.cancel ?? clearTimeout;
+
+  function later(id, chatId) {
+    const timer = schedule(() => {
+      active.delete(id);
+      watch(id, chatId);
+    }, pollIntervalMs);
+    active.set(id, timer);
+  }
+
+  async function poll(id, chatId) {
+    inflight.add(id);
+    try {
+      const result = await options.getMedia(id);
+      options.tracker.observeLookup(result);
+      if (result?.kind === 'status') {
+        const status = String(result.status ?? '').trim().toLowerCase();
+        if (TERMINAL_FAILURES.has(status)) {
+          options.tracker.noteDeliveryFailure(id, `media_${status}`);
+          completed.add(id);
+          return;
+        }
+        later(id, chatId);
+        return;
+      }
+      if (result?.kind !== 'file') {
+        options.tracker.noteDeliveryFailure(id, 'media_result_not_file');
+        completed.add(id);
+        return;
+      }
+      const localPath = await options.saveMedia(result);
+      options.tracker.noteSaved(id, localPath);
+      const sent = await options.deliver(chatId, localPath);
+      if (!sent) {
+        options.tracker.noteDeliveryFailure(id, 'channel_delivery_failed');
+        later(id, chatId);
+        return;
+      }
+      options.tracker.noteDelivered(id);
+      completed.add(id);
+    } catch (error) {
+      if (error?.code === 'MEDIA_QUALITY_REJECTED') {
+        options.tracker.noteRejected?.(id, error.message);
+        completed.add(id);
+        return;
+      }
+      options.tracker.noteDeliveryFailure(id, error?.message ?? error);
+      later(id, chatId);
+    } finally {
+      inflight.delete(id);
+    }
+  }
+
+  function watch(id, chatId) {
+    if (completed.has(id) || active.has(id) || inflight.has(id)) return;
+    options.tracker.associateDelivery(id, chatId);
+    void poll(id, chatId);
+  }
+
+  return {
+    watch,
+    resume() {
+      for (const job of options.tracker.pendingDeliveries()) watch(job.id, job.chatId);
+    },
+    stop() {
+      for (const timer of active.values()) cancel(timer);
+      active.clear();
+    },
+    async flushForTest() {
+      while (inflight.size > 0) await new Promise((resolve) => setImmediate(resolve));
+    },
+  };
+}
+
+module.exports = { createMediaAutoRetrievalController, parseAcceptedMediaJob };

package/bin/media-result-policy.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+const MIN_IMAGE_BYTES = 100000;
+const MIN_IMAGE_EDGE = 1024;
+
+function pngDimensions(data) {
+  const bytes = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  if (bytes.length < 24 || !bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return undefined;
+  }
+  if (bytes.toString('ascii', 12, 16) !== 'IHDR') return undefined;
+  return { width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) };
+}
+
+function jpegDimensions(data) {
+  const bytes = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  if (bytes.length < 4 || bytes[0] !== 0xff || bytes[1] !== 0xd8) return undefined;
+  let offset = 2;
+  while (offset + 9 < bytes.length) {
+    if (bytes[offset] !== 0xff) {
+      offset += 1;
+      continue;
+    }
+    const marker = bytes[offset + 1];
+    if ([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker)) {
+      return { height: bytes.readUInt16BE(offset + 5), width: bytes.readUInt16BE(offset + 7) };
+    }
+    if (marker === 0xd8 || marker === 0xd9) {
+      offset += 2;
+      continue;
+    }
+    const length = bytes.readUInt16BE(offset + 2);
+    if (length < 2) return undefined;
+    offset += 2 + length;
+  }
+  return undefined;
+}
+
+function validateCompletedMedia(result) {
+  if (result?.kind !== 'file' || !(result.data instanceof Uint8Array) || result.data.byteLength === 0) {
+    return { ok: false, reason: 'empty_media_payload' };
+  }
+  if (!String(result.mimeType).startsWith('image/')) return { ok: true };
+  const dimensions = result.mimeType === 'image/png'
+    ? pngDimensions(result.data)
+    : result.mimeType === 'image/jpeg'
+      ? jpegDimensions(result.data)
+      : undefined;
+  if (!dimensions) return { ok: false, reason: 'image_dimensions_unreadable' };
+  if (dimensions.width < MIN_IMAGE_EDGE || dimensions.height < MIN_IMAGE_EDGE) {
+    return { ok: false, reason: `image_dimensions_below_${MIN_IMAGE_EDGE}`, ...dimensions };
+  }
+  if (result.data.byteLength < MIN_IMAGE_BYTES) {
+    return { ok: false, reason: `image_payload_below_${MIN_IMAGE_BYTES}`, ...dimensions };
+  }
+  return { ok: true, ...dimensions };
+}
+
+module.exports = { validateCompletedMedia };

package/bin/pending-media-policy.cjs

@@ -1,5 +1,9 @@
 'use strict';
 
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
 const TERMINAL_STATUSES = new Set([
   'blocked',
   'cancelled',
@@ -10,34 +14,169 @@ const TERMINAL_STATUSES = new Set([
   'failed',
   'succeeded',
 ]);
+const STATE_VERSION = 1;
+const MAX_RECORDS = 100;
 
 function validMediaId(value) {
   return typeof value === 'string' && value.length > 0 && value.length <= 200
     && /^[A-Za-z0-9_-]+$/.test(value);
 }
 
+function normalizedStatus(value, fallback = 'processing') {
+  const status = typeof value === 'string' ? value.trim().toLowerCase() : '';
+  return status || fallback;
+}
+
 function terminalStatus(value) {
-  return typeof value === 'string' && TERMINAL_STATUSES.has(value.trim().toLowerCase());
+  return TERMINAL_STATUSES.has(normalizedStatus(value, ''));
+}
+
+function mediaRequestKey(requestPath, body) {
+  const stableBody = Object.fromEntries(Object.entries(body ?? {}).sort(([a], [b]) => a.localeCompare(b)));
+  return crypto.createHash('sha256')
+    .update(String(requestPath))
+    .update('\0')
+    .update(JSON.stringify(stableBody))
+    .digest('hex');
 }
 
-function createPendingMediaTracker() {
-  const pending = new Set();
+function safeRecord(value) {
+  if (!value || typeof value !== 'object' || !validMediaId(value.id)) return undefined;
+  return {
+    id: value.id,
+    status: normalizedStatus(value.status),
+    ...(typeof value.requestKey === 'string' && /^[a-f0-9]{64}$/.test(value.requestKey)
+      ? { requestKey: value.requestKey }
+      : {}),
+    ...(typeof value.chatId === 'string' && value.chatId.length > 0 && value.chatId.length <= 100
+      ? { chatId: value.chatId }
+      : {}),
+    ...(typeof value.localPath === 'string' && value.localPath.length > 0 && value.localPath.length <= 4096
+      ? { localPath: value.localPath }
+      : {}),
+    createdAt: Number.isFinite(value.createdAt) ? value.createdAt : Date.now(),
+    updatedAt: Number.isFinite(value.updatedAt) ? value.updatedAt : Date.now(),
+    ...(Number.isFinite(value.deliveredAt) ? { deliveredAt: value.deliveredAt } : {}),
+    ...(typeof value.lastError === 'string' && value.lastError.length > 0
+      ? { lastError: value.lastError.slice(0, 500) }
+      : {}),
+  };
+}
+
+function createPendingMediaTracker(options = {}) {
+  const statePath = typeof options.statePath === 'string' && options.statePath.length > 0
+    ? options.statePath
+    : undefined;
+  const now = typeof options.now === 'function' ? options.now : Date.now;
+  const records = new Map();
+
+  function load() {
+    if (!statePath) return;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+      if (parsed?.version !== STATE_VERSION || !Array.isArray(parsed.jobs)) return;
+      for (const value of parsed.jobs) {
+        const record = safeRecord(value);
+        if (record) records.set(record.id, record);
+      }
+    } catch {}
+  }
+
+  function persist() {
+    if (!statePath) return;
+    const jobs = [...records.values()]
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .slice(0, MAX_RECORDS);
+    records.clear();
+    for (const job of jobs) records.set(job.id, job);
+    fs.mkdirSync(path.dirname(statePath), { recursive: true, mode: 0o700 });
+    const temporary = `${statePath}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify({ version: STATE_VERSION, jobs })}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, statePath);
+  }
+
+  function change(id, updates) {
+    if (!validMediaId(id)) return undefined;
+    const existing = records.get(id) ?? {
+      id,
+      status: 'processing',
+      createdAt: now(),
+      updatedAt: now(),
+    };
+    const record = safeRecord({ ...existing, ...updates, id, updatedAt: now() });
+    if (!record) return undefined;
+    records.set(id, record);
+    persist();
+    return record;
+  }
+
+  load();
 
   return {
-    observeSubmission(job) {
+    observeSubmission(job, requestKey) {
       if (!validMediaId(job?.id)) return;
-      if (terminalStatus(job?.status)) pending.delete(job.id);
-      else pending.add(job.id);
+      change(job.id, {
+        status: normalizedStatus(job.status),
+        ...(typeof requestKey === 'string' ? { requestKey } : {}),
+      });
     },
     observeLookup(result) {
       if (!validMediaId(result?.id)) return;
-      if (result.kind !== 'status' || terminalStatus(result.status)) pending.delete(result.id);
-      else pending.add(result.id);
+      if (result.kind === 'file' || result.kind === 'text') {
+        change(result.id, { status: 'complete' });
+        return;
+      }
+      change(result.id, { status: normalizedStatus(result.status) });
+    },
+    findReusableRequest(requestKey) {
+      if (typeof requestKey !== 'string') return undefined;
+      const record = [...records.values()]
+        .filter((job) => job.requestKey === requestKey && job.deliveredAt === undefined)
+        .sort((a, b) => b.updatedAt - a.updatedAt)[0];
+      if (!record || (terminalStatus(record.status) && record.status !== 'complete' && record.status !== 'completed')) {
+        return undefined;
+      }
+      return { id: record.id, status: record.status };
+    },
+    associateDelivery(id, chatId) {
+      if (typeof chatId !== 'string' || chatId.length === 0) return;
+      change(id, { chatId });
+    },
+    noteSaved(id, localPath) {
+      if (typeof localPath !== 'string' || localPath.length === 0) return;
+      change(id, { localPath, status: 'complete', lastError: undefined });
+    },
+    noteDelivered(id) {
+      change(id, { deliveredAt: now(), status: 'complete', lastError: undefined });
+    },
+    noteDeliveryFailure(id, error) {
+      change(id, { lastError: String(error ?? 'delivery_failed').slice(0, 500) });
+    },
+    noteRejected(id, error) {
+      change(id, {
+        status: 'failed',
+        lastError: String(error ?? 'media_quality_rejected').slice(0, 500),
+      });
+    },
+    pendingDeliveries() {
+      return [...records.values()]
+        .filter((job) => job.chatId !== undefined && job.deliveredAt === undefined
+          && (!terminalStatus(job.status) || job.status === 'complete' || job.status === 'completed'))
+        .sort((a, b) => a.createdAt - b.createdAt)
+        .map((job) => ({
+          id: job.id,
+          chatId: job.chatId,
+          status: job.status,
+          ...(job.localPath === undefined ? {} : { localPath: job.localPath }),
+        }));
     },
     ids() {
-      return [...pending];
+      return [...records.values()]
+        .filter((job) => !terminalStatus(job.status))
+        .sort((a, b) => a.createdAt - b.createdAt)
+        .map((job) => job.id);
     },
   };
 }
 
-module.exports = { createPendingMediaTracker };
+module.exports = { createPendingMediaTracker, mediaRequestKey };

package/bin/turn-tool-performance-policy.cjs

@@ -5,13 +5,20 @@ const TOOL_SCHEMA_MAX_TOKENS = 32_000;
 const DEFERRED_TOOL_LOADER_NAME = 'ToolSearch';
 const MAX_PERSISTENT_DEFERRED_TOOLS = 4;
 const MAX_TOOL_SEARCH_QUERY_CHARS = 1_000;
+const MAX_AUTO_RANKED_TOOLS = 2;
+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([
     'current', 'inbox', 'latest', 'message', 'messages', 'nachricht', 'nachrichten', 'queue', 'queued',
-    'recent', 'update', 'updates',
+    'recent', 'letzte', 'letzten', 'letzter', 'vergangen', 'update', 'updates',
   ]),
   Object.freeze([
     'chat', 'conversation', 'history', 'log', 'logs', 'processed', 'protokoll', 'transcript', 'verlauf',
@@ -165,6 +172,96 @@ function relatedSearchTerms(token) {
   return group || [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];
+}
+
+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 nameTokens = rankingTokens(`${name.replaceAll('_', ' ')} ${leaf.replaceAll('_', ' ')}`);
+  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 new Set();
+  const queryTokens = [...new Set(rankingIntentTexts(value).flatMap(rankingTokens))];
+  if (queryTokens.length === 0) return 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;
+    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;
+    }
+    const highConfidence = matchedTokens >= 2 || (exactNameMatches >= 1 && score >= 10);
+    return highConfidence ? { 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 searchRelatedDeferredTools(tools, query, options = {}) {
   const normalized = normalizeDeferredToolQuery(query).toLowerCase();
   if (!normalized || normalized.startsWith('select:')) return [];
@@ -351,6 +448,7 @@ module.exports = {
   mediaGenerationToolNamesForText,
   mediaToolNamesForTurnText,
   normalizeDeferredToolQuery,
+  rankedToolNamesForTurnText,
   rememberDeferredToolAfterNotFound,
   toolSchemaBudgetTokens,
 };

package/blun.mjs

@@ -261514,7 +261514,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_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, 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 BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaToolNamesForTurnText, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, 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();
@@ -261531,7 +261531,7 @@ var init_turn = __esmMin((() => {
 	init_tool_result_budget();
 	init_user_message_offload();
 	init_assistant_message_offload();
-	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, mediaToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
+	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, mediaToolNamesForTurnText, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
 	({ projectRecurringCronHistory } = createRequire(import.meta.url)("./bin/recurring-cron-history-policy.cjs"));
 	({ TelegramDeliveryLedger } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
 	({ createRuntimeCognitiveTurnLifecycle } = createRequire(import.meta.url)("./bin/cognitive-turn-lifecycle.cjs"));
@@ -262265,12 +262265,13 @@ var init_turn = __esmMin((() => {
 				variant: "cognitive_continuity"
 			});
 			this.setActiveSteerAcceptance(turnId, true);
+			const turnText = blunExtractText(input);
 			const turnNeedsTools = blunTurnNeedsTools(input, origin);
 			const turnHasAttachment = blunTurnHasAttachment(input);
 			const turnThinkingEffort = turnHasAttachment ? void 0 : selectThinkingEffortForTurn(blunExtractText(blunThinkingIntentInput(input)), origin.kind);
 			const fastConversation = turnThinkingEffort === "off" || turnThinkingEffort === "low";
 			const pendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
-			const requiredToolNames = mediaToolNamesForTurnText(blunExtractText(input));
+			const requiredToolNames = mediaToolNamesForTurnText(turnText);
 			const turnSystemPrompt = pendingMediaJobIds.length > 0 ? blunPendingMediaSystemPrompt(fastConversation ? this.agent.fastConversationSystemPrompt : this.agent.effectiveSystemPrompt, pendingMediaJobIds) : fastConversation ? this.agent.fastConversationSystemPrompt : void 0;
 			const turnLLM = this.agent.llmForTurn(turnThinkingEffort, turnSystemPrompt);
 			let previousStepToolOutcome = "initial";
@@ -262285,10 +262286,13 @@ var init_turn = __esmMin((() => {
 					const originTools = blunToolsForOrigin(this.agent.injection.filterPersonalMemoryToolsForTurn(turnId, input, origin, this.agent.tools.loopTools), origin);
 					const compactConversationTool = originTools.find((tool) => tool.name === "CompactConversation");
 					const eligibleTools = originTools.filter((tool) => tool.name !== "CompactConversation" || this.agent.fullCompaction.isProactiveCompactionEligible());
+					const turnRequiredToolNames = new Set(requiredToolNames);
+					const rankedToolNames = rankedToolNamesForTurnText(eligibleTools, turnText);
+					for (const name of rankedToolNames) turnRequiredToolNames.add(name);
 					const toolSelection = fastConversation ? {
-						tools: [...blunFastConversationTools(eligibleTools, input, pendingMediaJobIds, requiredToolNames)],
+						tools: [...blunFastConversationTools(eligibleTools, input, pendingMediaJobIds, turnRequiredToolNames)],
 						deferredToolCount: 0
-					} : turnNeedsTools ? blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, requiredToolNames) : {
+					} : turnNeedsTools ? blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, turnRequiredToolNames) : {
 						tools: [],
 						deferredToolCount: 0
 					};
@@ -262356,7 +262360,9 @@ var init_turn = __esmMin((() => {
 								const steerThinkingEffort = "low";
 								const steerPendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
 								const steerLLM = this.agent.llmForTurn(steerThinkingEffort, blunPendingMediaSystemPrompt(this.agent.fastConversationSystemPrompt, steerPendingMediaJobIds));
-								const steerRequiredToolNames = mediaToolNamesForTurnText(blunExtractText(steerInput));
+								const steerText = blunExtractText(steerInput);
+								const steerRequiredToolNames = mediaToolNamesForTurnText(steerText);
+								for (const name of rankedToolNamesForTurnText(eligibleTools, steerText)) steerRequiredToolNames.add(name);
 								const steerTools = [...blunFastConversationTools(eligibleTools, steerInput, steerPendingMediaJobIds, steerRequiredToolNames)];
 								const steerHistory = () => blunFastConversationHistory(this.agent.context.history);
 								const buildSteerMessages = () => this.agent.context.project(steerHistory(), { dropOrphanResults: true });
@@ -312949,9 +312955,9 @@ async function assertSuccess(response, operation) {
 	} catch {}
 	throw new Error(`${operation} failed: HTTP ${String(response.status)}${detail ? `: ${detail}` : ""}`);
 }
-var createPendingMediaTracker, BlunMediaService;
+var createPendingMediaTracker, mediaRequestKey, activeBlunMediaService, BlunMediaService;
 var init_blun_media = __esmMin((() => {
-	({ createPendingMediaTracker } = createRequire(import.meta.url)("./bin/pending-media-policy.cjs"));
+	({ createPendingMediaTracker, mediaRequestKey } = createRequire(import.meta.url)("./bin/pending-media-policy.cjs"));
 	BlunMediaService = class {
 		tokenProvider;
 		apiKey;
@@ -312959,7 +312965,7 @@ var init_blun_media = __esmMin((() => {
 		defaultHeaders;
 		customHeaders;
 		fetchImpl;
-		pendingMedia = createPendingMediaTracker();
+		pendingMedia;
 		constructor(options) {
 			this.tokenProvider = options.tokenProvider;
 			this.apiKey = options.apiKey;
@@ -312967,6 +312973,8 @@ var init_blun_media = __esmMin((() => {
 			this.defaultHeaders = options.defaultHeaders ?? {};
 			this.customHeaders = options.customHeaders ?? {};
 			this.fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+			this.pendingMedia = createPendingMediaTracker({ statePath: join(resolveBlunHome$1(), "media", "pending-jobs.json") });
+			activeBlunMediaService = this;
 		}
 		generateImage(prompt, options) {
 			return this.submit("/images/generations", { prompt }, options);
@@ -313036,6 +313044,9 @@ var init_blun_media = __esmMin((() => {
 			});
 		}
 		async submit(path, body, options) {
+			const requestKey = mediaRequestKey(path, body);
+			const reusable = this.pendingMedia.findReusableRequest(requestKey);
+			if (reusable !== void 0) return reusable;
 			const response = await this.request(path, {
 				method: "POST",
 				body: JSON.stringify(body)
@@ -313043,7 +313054,7 @@ var init_blun_media = __esmMin((() => {
 			if (response.status === 409) throw await blockedSubmissionError(response);
 			await assertSuccess(response, "Media request");
 			const job = parseJob(await response.json());
-			this.pendingMedia.observeSubmission(job);
+			this.pendingMedia.observeSubmission(job, requestKey);
 			return job;
 		}
 		trackMediaLookup(result) {
@@ -313053,6 +313064,9 @@ var init_blun_media = __esmMin((() => {
 		pendingMediaJobIds() {
 			return this.pendingMedia.ids();
 		}
+		pendingMediaTracker() {
+			return this.pendingMedia;
+		}
 		async request(path, init, options) {
 			const firstToken = await this.resolveToken(false);
 			const first = await this.fetchWithToken(path, init, options, firstToken);
@@ -508124,6 +508138,7 @@ var SessionEventHandler = class {
 			mediaKind: mediaKindForToolName(matchedCall.name),
 			phase: "failed"
 		});
+		if (matchedCall !== void 0 && matchedCall.name !== "GetMedia" && isMediaToolName(matchedCall.name) && event.isError !== true) this.host.trackChannelMediaJob(event.output);
 		if (matchedCall?.name === "GetMedia" && event.isError !== true) this.host.runChannelMediaFallback(event.output);
 		this.subAgentEventHandler.handleAgentSwarmToolResult(event.toolCallId, resultData, event.isError === true);
 		if (matchedCall !== void 0 && matchedCall.name === "TodoList" && !event.isError) {
@@ -514706,6 +514721,9 @@ function outboxDeliveredFile(marker, chatId, filePath) {
 }
 var retryTelegramMediaDelivery, retryableTelegramMediaFailure;
 ({ retryTelegramMediaDelivery, retryableTelegramMediaFailure } = createRequire(import.meta.url)("./bin/telegram-media-delivery-policy.cjs"));
+var createMediaAutoRetrievalController, parseAcceptedMediaJob, validateCompletedMedia;
+({ createMediaAutoRetrievalController, parseAcceptedMediaJob } = createRequire(import.meta.url)("./bin/media-auto-retrieval-policy.cjs"));
+({ validateCompletedMedia } = createRequire(import.meta.url)("./bin/media-result-policy.cjs"));
 var { isPrivateInternalStatusReply, sanitizePrivateConversationReply } = createRequire(import.meta.url)("./bin/telegram-private-conversation-policy.cjs");
 const TELEGRAM_TEXT_LIMIT = 4096;
 const TELEGRAM_ATTACHMENT_LIMIT = 50 * 1024 * 1024;
@@ -514751,6 +514769,26 @@ function completedMediaLocalPath(output) {
 	const candidate = /Media job [^\r\n]+ is complete\. Local file: (.+?)\. The BLUN host/u.exec(text)?.[1]?.trim();
 	return candidate === void 0 || candidate.length === 0 ? void 0 : safeCompletedMediaPath(candidate);
 }
+function completedMediaJobId(output) {
+	const text = Array.isArray(output) ? output.filter((part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n") : typeof output === "string" ? output : "";
+	return /Media job ([A-Za-z0-9_-]{1,200}) is complete\./u.exec(text)?.[1];
+}
+async function saveAutoRetrievedMedia(result) {
+	const quality = validateCompletedMedia(result);
+	if (!quality.ok) {
+		const error = new Error(`Media quality gate rejected ${result.id}: ${quality.reason}`);
+		error.code = "MEDIA_QUALITY_REJECTED";
+		throw error;
+	}
+	const outputDir = mediaDir();
+	await mkdir(outputDir, {
+		recursive: true,
+		mode: 448
+	});
+	const localPath = join(outputDir, `${safeMediaId(result.id)}.${extensionForMediaType(result.mimeType)}`);
+	await writeFile(localPath, result.data, { mode: 384 });
+	return localPath;
+}
 /** Telegram group/supergroup ids are negative; DMs are the positive user id. */
 function isGroupChat(chatId) {
 	return chatId.startsWith("-");
@@ -515956,6 +515994,7 @@ var BlunTUI = class {
 	mediaActivityStore = new MediaActivityStore();
 	mediaActivityTickTimer;
 	mediaActivityExpanded = false;
+	mediaAutoRetrieval;
 	lastHistoryContent;
 	inputDraftTimer;
 	pendingInputDraft;
@@ -517431,16 +517470,36 @@ var BlunTUI = class {
 	/** See SessionEventHost.runChannelReplyFallback — called at turn end. */
 	channelMediaDeliveries = /* @__PURE__ */ new Set();
 	channelMediaDeliveryFailures = /* @__PURE__ */ new Set();
+	ensureMediaAutoRetrieval() {
+		if (this.mediaAutoRetrieval !== void 0) return this.mediaAutoRetrieval;
+		const service = activeBlunMediaService;
+		if (service === void 0) return void 0;
+		this.mediaAutoRetrieval = createMediaAutoRetrievalController({
+			tracker: service.pendingMediaTracker(),
+			getMedia: (id) => service.getMedia(id),
+			saveMedia: saveAutoRetrievedMedia,
+			deliver: sendMediaReplyFallback
+		});
+		return this.mediaAutoRetrieval;
+	}
+	trackChannelMediaJob(output) {
+		const guard = this.pendingChannelReplyGuard;
+		const id = parseAcceptedMediaJob(typeof output === "string" ? output : "");
+		if (guard === void 0 || id === void 0) return;
+		this.ensureMediaAutoRetrieval()?.watch(id, guard.chatId);
+	}
 	/** Deliver completed media at tool-result time so later queued work cannot hide it. */
 	runChannelMediaFallback(output) {
 		const guard = this.pendingChannelReplyGuard;
 		const filePath = completedMediaLocalPath(output);
+		const jobId = completedMediaJobId(output);
 		if (guard === void 0 || filePath === void 0) return;
 		const deliveryKey = `${guard.chatId}\0${filePath}`;
 		if (this.channelMediaDeliveries.has(deliveryKey)) return;
 		this.channelMediaDeliveries.add(deliveryKey);
 		sendMediaReplyFallback(guard.chatId, filePath).then((sent) => {
 			if (sent) {
+				if (jobId !== void 0) activeBlunMediaService?.pendingMediaTracker().noteDelivered(jobId);
 				this.channelMediaDeliveryFailures.delete(deliveryKey);
 				return;
 			}
@@ -517496,6 +517555,7 @@ var BlunTUI = class {
 	connectTelegramChannel() {
 		process.env["BLUN_TELEGRAM_ATTACH"] = "on";
 		this.startTelegramChannel();
+		this.ensureMediaAutoRetrieval()?.resume();
 		return this.telegramChannel !== void 0;
 	}
 	startTelegramChannel() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.394",
+  "version": "9.1.396",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {