blun-king-cli 9.1.393 → 9.1.395

package/LIESMICH.txt

@@ -326,6 +326,25 @@ Nachweisbare Arbeitsabläufe
 
 Alle Befehle funktionieren identisch mit `king`.
 
+Gemeinsamer kognitiver Speicherkern (optional)
+------------------------------------------------
+
+Ohne zusätzliche Konfiguration bleibt der bisherige lokale SQLite-Speicher
+aktiv. Betreiber können einen gemeinsamen, portalneutralen Speicherkern
+ausdrücklich über BLUN_COGNITIVE_MEMORY_ADAPTER_MODULE wählen. Der Wert muss
+auf eine absolute, kanonische CommonJS-Datei zeigen.
+
+Das Modul exportiert synchron createCognitiveMemoryAdapter(context) und liefert
+einen Adapter mit Vertragsversion 6. Relative Pfade, symbolische Verknüpfungen,
+asynchrone Fabriken und abweichende Vertragsversionen werden geschlossen
+abgewiesen. Der Adapter erhält nur die Vertragsversion, das Profilverzeichnis
+sowie Mandanten-, Agenten- und Anzeigenamen. Zugangsdaten werden nicht
+übergeben.
+
+Damit kann derselbe geprüfte Ereignisstrom über CLI und Portale hinweg gelesen,
+korrigiert und zurückgezogen werden. Ohne den optionalen Anbieter entstehen
+keine neuen Netzwerkzugriffe und keine Verhaltensänderung.
+
 Medienerzeugung
 ---------------
 Für Medienaufträge bleiben GenerateImage, GenerateVideo, GenerateSpeech und

package/README.md

@@ -338,6 +338,24 @@ Version 9.1.0 enthält sieben zusätzliche, getrennt nutzbare Befehlsgruppen:
 
 Sie stehen unter `blun` und `king` identisch zur Verfügung.
 
+## Gemeinsamer kognitiver Speicherkern (optional)
+
+Ohne zusätzliche Konfiguration bleibt der bisherige lokale SQLite-Speicher
+aktiv. Betreiber können einen gemeinsamen, portalneutralen Speicherkern
+ausdrücklich über `BLUN_COGNITIVE_MEMORY_ADAPTER_MODULE` wählen. Der Wert muss
+auf eine absolute, kanonische CommonJS-Datei zeigen.
+
+Das Modul exportiert synchron `createCognitiveMemoryAdapter(context)` und
+liefert einen Adapter mit Vertragsversion 6. Relative Pfade, symbolische
+Verknüpfungen, asynchrone Fabriken und abweichende Vertragsversionen werden
+geschlossen abgewiesen. Der Adapter erhält nur die Vertragsversion, das
+Profilverzeichnis sowie Mandanten-, Agenten- und Anzeigenamen. Zugangsdaten
+werden nicht übergeben.
+
+Damit kann derselbe geprüfte Ereignisstrom über CLI und Portale hinweg gelesen,
+korrigiert und zurückgezogen werden. Ohne den optionalen Anbieter entstehen
+keine neuen Netzwerkzugriffe und keine Verhaltensänderung.
+
 ## Medienerzeugung
 
 Für Medienaufträge bleiben `GenerateImage`, `GenerateVideo`, `GenerateSpeech` und

package/bin/cognitive-memory-provider.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  COGNITIVE_MEMORY_ADAPTER_VERSION,
+  assertCognitiveMemoryAdapter,
+} = require('./cognitive-memory-adapter.cjs');
+
+const PROVIDER_ENV = 'BLUN_COGNITIVE_MEMORY_ADAPTER_MODULE';
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+
+function fail(code) {
+  const error = new Error(code);
+  error.code = code;
+  throw error;
+}
+
+function canonicalFile(input) {
+  const configured = String(input ?? '').trim();
+  if (!configured || !path.isAbsolute(configured)) fail('COGNITIVE_MEMORY_PROVIDER_PATH_INVALID');
+  const resolved = path.resolve(configured);
+  let stat;
+  let canonical;
+  try {
+    stat = fs.lstatSync(resolved);
+    canonical = fs.realpathSync(resolved);
+  } catch {
+    fail('COGNITIVE_MEMORY_PROVIDER_PATH_INVALID');
+  }
+  if (!stat.isFile() || stat.isSymbolicLink()
+      || path.normalize(canonical).toLowerCase() !== path.normalize(resolved).toLowerCase()) {
+    fail('COGNITIVE_MEMORY_PROVIDER_PATH_INVALID');
+  }
+  return canonical;
+}
+
+function boundedContext({ home, tenantId, agentId, agentName }) {
+  const tenant = String(tenantId ?? '').trim();
+  const agent = String(agentId ?? '').trim();
+  const name = String(agentName ?? '').trim();
+  let canonicalHome;
+  try {
+    const stat = fs.lstatSync(path.resolve(String(home ?? '')));
+    canonicalHome = fs.realpathSync(path.resolve(String(home ?? '')));
+    if (!stat.isDirectory() || stat.isSymbolicLink()) fail('COGNITIVE_MEMORY_PROVIDER_CONTEXT_INVALID');
+  } catch (error) {
+    if (error?.code === 'COGNITIVE_MEMORY_PROVIDER_CONTEXT_INVALID') throw error;
+    fail('COGNITIVE_MEMORY_PROVIDER_CONTEXT_INVALID');
+  }
+  if (!SAFE_ID_RE.test(tenant) || !SAFE_ID_RE.test(agent) || !name || name.length > 128
+      || /[\u0000-\u001f\u007f]/u.test(name)) {
+    fail('COGNITIVE_MEMORY_PROVIDER_CONTEXT_INVALID');
+  }
+  return Object.freeze({
+    contractVersion: COGNITIVE_MEMORY_ADAPTER_VERSION,
+    home: canonicalHome,
+    tenantId: tenant,
+    agentId: agent,
+    agentName: name,
+  });
+}
+
+function loadConfiguredCognitiveMemoryAdapter({
+  modulePath,
+  env = process.env,
+  home,
+  tenantId,
+  agentId,
+  agentName,
+} = {}) {
+  const configured = modulePath === undefined ? env?.[PROVIDER_ENV] : modulePath;
+  if (!String(configured ?? '').trim()) return undefined;
+  const providerPath = canonicalFile(configured);
+  const provider = require(providerPath);
+  if (!provider || typeof provider.createCognitiveMemoryAdapter !== 'function') {
+    fail('COGNITIVE_MEMORY_PROVIDER_FACTORY_REQUIRED');
+  }
+  const adapter = provider.createCognitiveMemoryAdapter(boundedContext({
+    home,
+    tenantId,
+    agentId,
+    agentName,
+  }));
+  if (adapter && typeof adapter.then === 'function') fail('COGNITIVE_MEMORY_PROVIDER_ASYNC_UNSUPPORTED');
+  return assertCognitiveMemoryAdapter(adapter);
+}
+
+module.exports = {
+  PROVIDER_ENV,
+  loadConfiguredCognitiveMemoryAdapter,
+};

package/bin/cognitive-turn-lifecycle.cjs

@@ -4,6 +4,7 @@ const crypto = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 const { openCognitiveMemoryAdapter } = require('./cognitive-memory-adapter.cjs');
+const { loadConfiguredCognitiveMemoryAdapter } = require('./cognitive-memory-provider.cjs');
 const { buildCognitiveContextProjection } = require('./cognitive-context-projection.cjs');
 const { buildCognitiveFocusProjection } = require('./cognitive-focus-projection.cjs');
 const { authorizeAttentionCandidate } = require('./cognitive-attention-runtime.cjs');
@@ -521,6 +522,7 @@ function createRuntimeCognitiveTurnLifecycle({
   agentId,
   runtimeId,
   memoryAdapter,
+  memoryAdapterModule,
   now,
 } = {}) {
   const resolvedHome = String(home ?? '').trim();
@@ -537,12 +539,25 @@ function createRuntimeCognitiveTurnLifecycle({
     agentId: explicitAgent || manifestIdentity?.agentId || '',
   };
   const hasSharedIdentity = Boolean(identity.tenantId && identity.agentId);
+  const resolvedTenantId = hasSharedIdentity
+    ? identity.tenantId : digestId('home', [resolvedHome.toLowerCase()]);
+  const resolvedAgentId = hasSharedIdentity
+    ? identity.agentId : digestId('agent', [resolvedAgent.toLowerCase()]);
+  const resolvedMemoryAdapter = memoryAdapter === undefined
+    ? loadConfiguredCognitiveMemoryAdapter({
+      modulePath: memoryAdapterModule,
+      home: resolvedHome,
+      tenantId: resolvedTenantId,
+      agentId: resolvedAgentId,
+      agentName: resolvedAgent,
+    })
+    : memoryAdapter;
   return createCognitiveTurnLifecycle({
     home: resolvedHome,
-    tenantId: hasSharedIdentity ? identity.tenantId : digestId('home', [resolvedHome.toLowerCase()]),
-    agentId: hasSharedIdentity ? identity.agentId : digestId('agent', [resolvedAgent.toLowerCase()]),
+    tenantId: resolvedTenantId,
+    agentId: resolvedAgentId,
     runtimeId,
-    memoryAdapter,
+    memoryAdapter: resolvedMemoryAdapter,
     now,
   });
 }

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/blun.mjs

@@ -312949,9 +312949,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 +312959,7 @@ var init_blun_media = __esmMin((() => {
 		defaultHeaders;
 		customHeaders;
 		fetchImpl;
-		pendingMedia = createPendingMediaTracker();
+		pendingMedia;
 		constructor(options) {
 			this.tokenProvider = options.tokenProvider;
 			this.apiKey = options.apiKey;
@@ -312967,6 +312967,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 +313038,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 +313048,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 +313058,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 +508132,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 +514715,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 +514763,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 +515988,7 @@ var BlunTUI = class {
 	mediaActivityStore = new MediaActivityStore();
 	mediaActivityTickTimer;
 	mediaActivityExpanded = false;
+	mediaAutoRetrieval;
 	lastHistoryContent;
 	inputDraftTimer;
 	pendingInputDraft;
@@ -517431,16 +517464,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 +517549,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.393",
+  "version": "9.1.395",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {