omnius 1.0.155 → 1.0.156

package/dist/index.js

@@ -11854,6 +11854,12 @@ var _sponsorDailyTokensUsed = 0;
 var _sponsorDailyResetAt = Date.now() + 86400000;
 var _sponsorBlockedRequests = 0;
 var _sponsorTokenRateSamples = [];
+var _sponsorMediaConfig = null;
+var _sponsorMediaActive = {};
+var _sponsorMediaRequestWindow = {};
+var _sponsorMediaDailyJobs = {};
+var _sponsorMediaDailyResetAt = Date.now() + 86400000;
+var _mediaByRequest = {};
 
 function _sponsorPrune(now) {
   while (_sponsorRequestWindow.length > 0 && _sponsorRequestWindow[0] < now - 60000) _sponsorRequestWindow.shift();
@@ -11927,6 +11933,80 @@ function _sponsorRecordUsage(inputTokens, outputTokens, includeRate) {
   if (includeRate !== false) _sponsorRecordTokenRate(output);
 }
 
+function _sponsorMediaPrune(now) {
+  now = now || Date.now();
+  if (_sponsorMediaDailyResetAt <= now) {
+    _sponsorMediaDailyJobs = {};
+    _sponsorMediaDailyResetAt = now + 86400000;
+  }
+  for (var key of Object.keys(_sponsorMediaRequestWindow)) {
+    var arr = _sponsorMediaRequestWindow[key] || [];
+    while (arr.length > 0 && arr[0] < now - 60000) arr.shift();
+    _sponsorMediaRequestWindow[key] = arr;
+  }
+}
+
+function _sponsorMediaLimitsFor(modality) {
+  if (!_sponsorMediaConfig || !_sponsorMediaConfig[modality]) return null;
+  return _sponsorMediaConfig[modality];
+}
+
+function _sponsorMediaAdmit(modality) {
+  var limits = _sponsorMediaLimitsFor(modality);
+  if (!limits || !limits.enabled) return { ok: false, reason: modality + ' sponsorship is disabled.' };
+  var now = Date.now();
+  _sponsorMediaPrune(now);
+  var active = _sponsorMediaActive[modality] || 0;
+  var window = _sponsorMediaRequestWindow[modality] || [];
+  var daily = _sponsorMediaDailyJobs[modality] || 0;
+  var maxConcurrent = Math.max(0, Number(limits.maxConcurrent || 0));
+  var jobsPerMinute = Math.max(0, Number(limits.jobsPerMinute || 0));
+  var jobsPerDay = Math.max(0, Number(limits.jobsPerDay || 0));
+  if (maxConcurrent <= 0 || jobsPerMinute <= 0 || jobsPerDay <= 0) {
+    _sponsorBlockedRequests++;
+    return { ok: false, reason: modality + ' sponsorship is paused or has no quota configured.' };
+  }
+  if (_sponsorLimits && _sponsorActiveRequests >= _sponsorLimits.maxConcurrent) {
+    _sponsorBlockedRequests++;
+    return { ok: false, reason: 'Too many sponsor requests (' + _sponsorActiveRequests + '/' + _sponsorLimits.maxConcurrent + '). Try again shortly.' };
+  }
+  if (active >= maxConcurrent) {
+    _sponsorBlockedRequests++;
+    return { ok: false, reason: 'Too many concurrent ' + modality + ' jobs (' + active + '/' + maxConcurrent + '). Try again shortly.' };
+  }
+  if (window.length >= jobsPerMinute) {
+    _sponsorBlockedRequests++;
+    return { ok: false, reason: modality + ' rate limited (' + jobsPerMinute + ' jobs/min).' };
+  }
+  if (daily >= jobsPerDay) {
+    _sponsorBlockedRequests++;
+    return { ok: false, reason: modality + ' daily job budget exhausted.' };
+  }
+  _sponsorActiveRequests++;
+  _sponsorMediaActive[modality] = active + 1;
+  window.push(now);
+  _sponsorMediaRequestWindow[modality] = window;
+  _sponsorMediaDailyJobs[modality] = daily + 1;
+  return { ok: true };
+}
+
+function _sponsorMediaRelease(modality) {
+  if (_sponsorActiveRequests > 0) _sponsorActiveRequests--;
+  var active = _sponsorMediaActive[modality] || 0;
+  if (active > 0) _sponsorMediaActive[modality] = active - 1;
+}
+
+function _sponsorMediaGatewaySnapshot() {
+  _sponsorMediaPrune(Date.now());
+  return {
+    active: _sponsorMediaActive,
+    requestsInWindow: Object.fromEntries(Object.keys(_sponsorMediaRequestWindow).map(function(k) { return [k, (_sponsorMediaRequestWindow[k] || []).length]; })),
+    dailyJobsUsed: _sponsorMediaDailyJobs,
+    dailyResetAt: _sponsorMediaDailyResetAt,
+    limits: _sponsorMediaConfig,
+  };
+}
+
 function _sponsorGatewaySnapshot() {
   var now = Date.now();
   _sponsorPrune(now);
@@ -11938,6 +12018,7 @@ function _sponsorGatewaySnapshot() {
     blockedRequests: _sponsorBlockedRequests,
     tokensPerSecond: _sponsorTokenRate(now),
     limits: _sponsorLimits,
+    media: _sponsorMediaGatewaySnapshot(),
   };
 }
 
@@ -12916,6 +12997,10 @@ async function handleCmd(cmd) {
         } catch {}
 	        var sponsorLimitsArg = {};
 	        try { sponsorLimitsArg = args.limits ? JSON.parse(args.limits) : {}; } catch {}
+	        var sponsorServicesArg = [];
+	        try {
+	          if (args.services) sponsorServicesArg = typeof args.services === 'string' ? JSON.parse(args.services) : args.services;
+	        } catch {}
 	        var sponsorData = {
           type: 'sponsor.announce',
           peerId: (connected ? nexus.peerId : 'unknown') || 'unknown',
@@ -12923,6 +13008,8 @@ async function handleCmd(cmd) {
           name: args.name || 'Anonymous Sponsor',
           models: _saModels.length > 0 ? _saModels : _saModelDetails.map(function(m) { return m.name; }),
           modelDetails: _saModelDetails, // NX-07: per-model capacity
+          services: Array.isArray(sponsorServicesArg) ? sponsorServicesArg : [],
+          mediaCapabilities: Array.isArray(sponsorServicesArg) ? sponsorServicesArg.filter(function(s) { return s && s.kind && s.kind !== 'llm'; }) : [],
           tunnelUrl: args.tunnel_url || null,
           authKey: args.auth_key || '',
 	          limits: {
@@ -13007,6 +13094,8 @@ async function handleCmd(cmd) {
           rateLimit: String(sponsorData.limits.maxRequestsPerMinute) + '/min',
           sponsor: sponsorData,
           models: sponsorData.models,
+          services: sponsorData.services,
+          mediaCapabilities: sponsorData.mediaCapabilities,
           limits: sponsorData.limits,
         });
         writeResp(id, { ok: true, output: 'Sponsor announced: ' + sponsorData.name + ' (' + sponsorData.models.length + ' models) [DHT+GossipSub+NATS+KV+Room]' });
@@ -14183,7 +14272,7 @@ async function handleCmd(cmd) {
         if (typeof nexus.getRegisteredCapabilities === 'function' && typeof nexus.unregisterCapability === 'function') {
           var oldCaps = nexus.getRegisteredCapabilities();
           for (var oci = 0; oci < oldCaps.length; oci++) {
-            if (oldCaps[oci].startsWith('inference:') || oldCaps[oci] === 'system_metrics' || oldCaps[oci] === '__list_capabilities') {
+            if (oldCaps[oci].startsWith('inference:') || oldCaps[oci].startsWith('media:') || oldCaps[oci] === 'system_metrics' || oldCaps[oci] === '__list_capabilities') {
               try { nexus.unregisterCapability(oldCaps[oci]); } catch {}
             }
           }
@@ -14217,6 +14306,18 @@ async function handleCmd(cmd) {
         } else {
           _sponsorLimits = null;
         }
+        try {
+          var mediaConfigRaw = args.media_config || args.media_limits || '';
+          if (mediaConfigRaw) {
+            var mediaHelpersForConfig = await import('@omnius/execution');
+            _sponsorMediaConfig = mediaHelpersForConfig.normalizeSponsorMediaConfig(JSON.parse(mediaConfigRaw));
+          } else {
+            _sponsorMediaConfig = null;
+          }
+        } catch (mediaConfigErr) {
+          dlog('expose: media sponsor config parse failed: ' + (mediaConfigErr.message || mediaConfigErr));
+          _sponsorMediaConfig = null;
+        }
 
         // Passthrough mode: forward from a remote /endpoint (Chutes, Groq, etc.)
         var isPassthrough = args.passthrough === 'true';
@@ -14762,6 +14863,228 @@ async function handleCmd(cmd) {
           });
         }
 
+        var mediaServices = [];
+        if (_sponsorMediaConfig) {
+          try {
+            var mediaModule = await import('@omnius/execution');
+            mediaServices = mediaModule.buildSponsorMediaServices(_sponsorMediaConfig);
+            for (var msi = 0; msi < mediaServices.length; msi++) {
+              const mediaService = mediaServices[msi];
+              if (typeof nexus.registerCapability === 'function') {
+                nexus.registerCapability(mediaService.capability, async (request, stream) => {
+                  var mediaStreamClosed = false;
+                  async function mediaWrite(msg) {
+                    if (mediaStreamClosed) return;
+                    try { await stream.write(msg); } catch (mwErr) {
+                      mediaStreamClosed = true;
+                      dlog('media stream.write failed: ' + (mwErr.message || mwErr));
+                    }
+                  }
+                  var mediaChunks = [];
+                  var mediaInputDone = false;
+                  stream.onData(function(msg) {
+                    if (msg.type === 'invoke.chunk') {
+                      mediaChunks.push(typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data));
+                    }
+                    if (msg.type === 'invoke.done' || msg.type === 'invoke.end' || msg.type === 'invoke.close') {
+                      mediaInputDone = true;
+                    }
+                  });
+                  await mediaWrite({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
+                  var mediaWaitMs = 0;
+                  while (!mediaInputDone && mediaChunks.length === 0 && mediaWaitMs < 5000) {
+                    await new Promise(function(r) { setTimeout(r, 10); });
+                    mediaWaitMs += 10;
+                  }
+                  var mediaRawInput = mediaChunks.join('');
+                  if (exposeAuthKey) {
+                    var mediaReqAuthKey = '';
+                    try {
+                      var mediaAuthData = JSON.parse(mediaRawInput);
+                      if (mediaAuthData && typeof mediaAuthData === 'object' && mediaAuthData.auth_key) mediaReqAuthKey = mediaAuthData.auth_key;
+                    } catch {}
+                    if (!mediaReqAuthKey && request.metadata && request.metadata.auth_key) mediaReqAuthKey = request.metadata.auth_key;
+                    if (mediaReqAuthKey !== exposeAuthKey) {
+                      await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'Unauthorized — invalid or missing auth key' });
+                      await mediaWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
+                      try { stream.close(); } catch {}
+                      return;
+                    }
+                  }
+
+                  var mediaAdmissionOpen = false;
+                  var mediaStart = Date.now();
+                  var mediaModality = mediaService.kind;
+                  var mediaSeq = 0;
+	                  try {
+	                    var parsedMediaInput;
+	                    try { parsedMediaInput = JSON.parse(mediaRawInput || '{}'); } catch { parsedMediaInput = { prompt: mediaRawInput || '' }; }
+	                    var mediaHelpers = await import('@omnius/execution');
+	                    var sanitized = mediaHelpers.sanitizeRemoteMediaGenerateRequest(parsedMediaInput, mediaService, _sponsorMediaConfig);
+	                    if (!sanitized.ok) {
+	                      throw new Error(sanitized.reason || 'Remote media request rejected');
+	                    }
+
+	                    var admission = _sponsorMediaAdmit(mediaModality);
+	                    if (!admission.ok) {
+	                      await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: mediaSeq++, event: 'error', data: admission.reason });
+	                      await mediaWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: mediaRawInput.length, outputBytes: 0 } });
+                      try {
+                        appendFileSync(meteringFile, JSON.stringify({
+                          timestamp: Date.now(),
+                          peerId: request.from || 'unknown',
+                          service: mediaService.capability,
+                          capability: mediaService.capability,
+                          modality: mediaModality,
+                          model: mediaService.model || 'auto',
+                          direction: 'inbound',
+                          blocked: true,
+                          reason: admission.reason,
+                          outputBytes: 0,
+                        }) + '\\n');
+                      } catch {}
+                      try { stream.close(); } catch {}
+                      return;
+	                    }
+	                    mediaAdmissionOpen = true;
+
+	                    var safeArgs = sanitized.value.args || {};
+                    var progressCb = async function(event) {
+                      var payload = {
+                        type: 'progress',
+                        stage: String(event && event.stage ? event.stage : 'run'),
+                        message: String(event && event.message ? event.message : ''),
+                        percent: event && typeof event.percent === 'number' ? event.percent : undefined,
+                      };
+                      await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: mediaSeq++, event: 'progress', data: JSON.stringify(payload) });
+                    };
+
+                    var tool;
+                    if (mediaModality === 'image') {
+                      tool = new mediaHelpers.ImageGenerateTool(process.cwd(), rawUrl);
+                    } else if (mediaModality === 'video') {
+                      tool = new mediaHelpers.VideoGenerateTool(process.cwd());
+                    } else {
+                      tool = new mediaHelpers.AudioGenerateTool(process.cwd());
+                    }
+                    if (tool && typeof tool.setProgressCallback === 'function') {
+                      tool.setProgressCallback(function(event) { progressCb(event).catch(function() {}); });
+                    }
+                    await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: mediaSeq++, event: 'progress', data: JSON.stringify({ type: 'progress', stage: 'start', message: 'Starting ' + mediaModality + ' generation' }) });
+                    var mediaResult = await tool.execute(safeArgs);
+                    if (!mediaResult || !mediaResult.success) {
+                      throw new Error((mediaResult && (mediaResult.error || mediaResult.output)) || 'Media generation failed');
+                    }
+                    var mutated = Array.isArray(mediaResult.mutatedFiles) ? mediaResult.mutatedFiles : [];
+                    var primaryPath = '';
+                    for (var mpi = 0; mpi < mutated.length; mpi++) {
+                      var pth = String(mutated[mpi] || '');
+                      if (mediaModality === 'image' && /\\.(png|jpe?g|webp)$/i.test(pth)) { primaryPath = pth; break; }
+                      if (mediaModality === 'video' && /\\.(mp4|webm)$/i.test(pth)) { primaryPath = pth; break; }
+                      if ((mediaModality === 'sound' || mediaModality === 'music') && /\\.(wav|mp3|flac|ogg)$/i.test(pth)) { primaryPath = pth; break; }
+                    }
+                    if (!primaryPath && mutated[0]) primaryPath = String(mutated[0]);
+                    if (!primaryPath || !existsSync(primaryPath)) throw new Error('Generated media artifact was not found');
+                    var artifactBytes = readFileSync(primaryPath);
+                    var limits = _sponsorMediaLimitsFor(mediaModality) || {};
+                    var maxBytes = Math.max(0, Number(limits.maxOutputBytes || 0));
+                    if (maxBytes > 0 && artifactBytes.length > maxBytes) {
+                      throw new Error('Generated artifact exceeds sponsor output limit (' + artifactBytes.length + '/' + maxBytes + ' bytes)');
+                    }
+                    var artifactId = mediaModality + '-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8);
+                    var filename = require('node:path').basename(primaryPath);
+                    var mime = mediaHelpers.mediaMimeFromPath(primaryPath, mediaModality);
+                    var sha = createHash('sha256').update(artifactBytes).digest('hex');
+                    await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: mediaSeq++, event: 'artifact.begin', data: JSON.stringify({ type: 'artifact.begin', artifactId: artifactId, filename: filename, mime: mime, sizeBytes: artifactBytes.length, sha256: sha }) });
+                    var chunkSize = 64 * 1024;
+                    var chunkSeq = 0;
+                    for (var off = 0; off < artifactBytes.length; off += chunkSize) {
+                      var chunk = artifactBytes.subarray(off, Math.min(off + chunkSize, artifactBytes.length));
+                      await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: mediaSeq++, event: 'artifact.chunk', data: JSON.stringify({ type: 'artifact.chunk', artifactId: artifactId, seq: chunkSeq++, dataBase64: chunk.toString('base64') }) });
+                    }
+                    await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: mediaSeq++, event: 'artifact.end', data: JSON.stringify({ type: 'artifact.end', artifactId: artifactId, sha256: sha, sizeBytes: artifactBytes.length }) });
+                    var metadata = {
+                      ok: true,
+                      type: 'result',
+                      modality: mediaModality,
+                      model: safeArgs.model || mediaService.model || 'auto',
+                      backend: safeArgs.backend || mediaService.backend || 'auto',
+                      artifact: { artifactId: artifactId, filename: filename, mime: mime, sizeBytes: artifactBytes.length, sha256: sha },
+                      output: mediaResult.output || '',
+                      durationMs: Date.now() - mediaStart,
+                      system: null,
+                    };
+                    try {
+                      var sm2 = await _collectSysMetrics();
+                      if (sm2) metadata.system = Object.assign({}, sm2, { gateway: _sponsorGatewaySnapshot() });
+                    } catch {}
+                    await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: mediaSeq++, event: 'result', data: JSON.stringify(metadata) });
+                    await mediaWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: mediaRawInput.length, outputBytes: artifactBytes.length } });
+                    _mediaByRequest[request.requestId] = {
+                      modality: mediaModality,
+                      model: String(safeArgs.model || mediaService.model || 'auto'),
+                      inputBytes: mediaRawInput.length,
+                      outputBytes: artifactBytes.length,
+                      durationMs: Date.now() - mediaStart,
+                      success: true,
+                    };
+                    try {
+                      appendFileSync(meteringFile, JSON.stringify({
+                        timestamp: Date.now(),
+                        peerId: request.from || 'unknown',
+                        service: mediaService.capability,
+                        capability: mediaService.capability,
+                        modality: mediaModality,
+                        model: String(safeArgs.model || mediaService.model || 'auto'),
+                        direction: 'inbound',
+                        inputBytes: mediaRawInput.length,
+                        outputBytes: artifactBytes.length,
+                        durationMs: Date.now() - mediaStart,
+                        success: true,
+                      }) + '\\n');
+                    } catch {}
+                  } catch (mediaErr) {
+                    var mediaErrMsg = mediaErr && mediaErr.message ? mediaErr.message : String(mediaErr);
+                    await mediaWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: mediaSeq++, event: 'error', data: mediaErrMsg });
+                    await mediaWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: mediaRawInput.length, outputBytes: 0 } });
+                    try {
+                      appendFileSync(meteringFile, JSON.stringify({
+                        timestamp: Date.now(),
+                        peerId: request.from || 'unknown',
+                        service: mediaService.capability,
+                        capability: mediaService.capability,
+                        modality: mediaModality,
+                        model: mediaService.model || 'auto',
+                        direction: 'inbound',
+                        inputBytes: mediaRawInput.length,
+                        outputBytes: 0,
+                        durationMs: Date.now() - mediaStart,
+                        success: false,
+                        reason: mediaErrMsg,
+                      }) + '\\n');
+                    } catch {}
+                  } finally {
+                    if (mediaAdmissionOpen) _sponsorMediaRelease(mediaModality);
+                    try { stream.close(); } catch {}
+                  }
+                });
+              }
+              await _publishCapabilityRecord(mediaService.capability, {
+                description: 'Omnius sponsored ' + mediaService.kind + ' generation',
+                pricing: 'sponsored',
+                rateLimit: String(mediaService.limits.jobsPerMinute || 'provider-policy') + '/min',
+                service: mediaService,
+                model: mediaService.model,
+                modality: mediaService.kind,
+                limits: mediaService.limits,
+              });
+            }
+            dlog('expose: registered ' + mediaServices.length + ' media sponsor capabilities');
+          } catch (mediaExposeErr) {
+            dlog('expose: media capability registration failed: ' + (mediaExposeErr.message || mediaExposeErr));
+          }
+        }
+
         // Register system_metrics capability — returns CPU/GPU/memory utilization
         if (typeof nexus.registerCapability === 'function') {
           nexus.registerCapability('system_metrics', async (request, stream) => {
@@ -14892,7 +15215,7 @@ async function handleCmd(cmd) {
                 quantization: pm.quantization || '',
               });
             }
-            var capsPayload = JSON.stringify({ capabilities: allCaps, models: modelsInfo, agentName: agentName, peerId: nexus.peerId });
+            var capsPayload = JSON.stringify({ capabilities: allCaps, models: modelsInfo, services: mediaServices, mediaCapabilities: mediaServices, agentName: agentName, peerId: nexus.peerId });
             await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'result', data: capsPayload });
             await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: capsPayload.length } });
             stream.close();
@@ -14910,12 +15233,14 @@ async function handleCmd(cmd) {
                 quantization: pm.quantization || '',
               };
             }),
+            services: mediaServices,
+            mediaCapabilities: mediaServices,
           });
         }
 
         // Write pricing menu to file
         const pricingFile = join(nexusDir, 'pricing.json');
-        writeFileSync(pricingFile, JSON.stringify({ updated: new Date().toISOString(), models: pricingMenu }, null, 2));
+        writeFileSync(pricingFile, JSON.stringify({ updated: new Date().toISOString(), models: pricingMenu, services: mediaServices }, null, 2));
         writeStatus({ exposedModels: pricingMenu.length });
 
         const lines = ['Exposed ' + pricingMenu.length + ' model(s) as nexus capabilities:'];
@@ -14925,6 +15250,13 @@ async function handleCmd(cmd) {
             : '$' + p.pricing.input_per_1m_tokens + '/$' + p.pricing.output_per_1m_tokens + ' per 1M tokens';
           lines.push('  inference:' + p.model + ' — ' + cost);
         }
+        if (mediaServices.length > 0) {
+          lines.push('');
+          lines.push('Exposed ' + mediaServices.length + ' media generation service(s):');
+          for (var msl = 0; msl < mediaServices.length; msl++) {
+            lines.push('  ' + mediaServices[msl].capability + ' — sponsored ' + mediaServices[msl].kind);
+          }
+        }
         lines.push('');
         lines.push('Pricing menu saved to ' + pricingFile);
         lines.push('Market rates: ' + Object.keys(marketRates).length + ' models from OpenRouter');
@@ -95984,7 +96316,7 @@ var require_auto = __commonJS({
 // ../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash32 } = __require("crypto");
+    var { createHash: createHash34 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -96295,14 +96627,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash32("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash34("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash32("sha256").update(result).digest("base64url");
+          return createHash34("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -132214,7 +132546,7 @@ var require_snapshot_recorder = __commonJS({
   "../node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
     var { writeFile: writeFile24, readFile: readFile23, mkdir: mkdir20 } = __require("node:fs/promises");
-    var { dirname: dirname43, resolve: resolve56 } = __require("node:path");
+    var { dirname: dirname44, resolve: resolve56 } = __require("node:path");
     var { setTimeout: setTimeout3, clearTimeout: clearTimeout3 } = __require("node:timers");
     var { InvalidArgumentError, UndiciError } = require_errors2();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -132445,7 +132777,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         const resolvedPath = resolve56(path12);
-        await mkdir20(dirname43(resolvedPath), { recursive: true });
+        await mkdir20(dirname44(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
           snapshot
@@ -238982,7 +239314,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes29, createHash: createHash32 } = __require("crypto");
+    var { randomBytes: randomBytes29, createHash: createHash34 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate2();
@@ -239642,7 +239974,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash32("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash34("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -240009,7 +240341,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash32 } = __require("crypto");
+    var { createHash: createHash34 } = __require("crypto");
     var extension3 = require_extension2();
     var PerMessageDeflate3 = require_permessage_deflate2();
     var subprotocol3 = require_subprotocol();
@@ -240310,7 +240642,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash32("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash34("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -246107,15 +246439,15 @@ var init_ls = __esm({
 });
 
 // ../node_modules/@helia/unixfs/dist/src/commands/mkdir.js
-async function mkdir6(parentCid, dirname43, blockstore, options2 = {}) {
-  if (dirname43.includes("/")) {
+async function mkdir6(parentCid, dirname44, blockstore, options2 = {}) {
+  if (dirname44.includes("/")) {
     throw new InvalidParametersError4("Path must not have slashes");
   }
   const entry = await exporter2(parentCid, blockstore, options2);
   if (entry.type !== "directory") {
     throw new NotADirectoryError(`${parentCid.toString()} was not a UnixFS directory`);
   }
-  log16("creating %s", dirname43);
+  log16("creating %s", dirname44);
   const metadata = new UnixFS({
     type: "directory",
     mode: options2.mode,
@@ -246131,9 +246463,9 @@ async function mkdir6(parentCid, dirname43, blockstore, options2 = {}) {
   await blockstore.put(emptyDirCid, buf);
   const [directory, pblink] = await Promise.all([
     cidToDirectory(parentCid, blockstore, options2),
-    cidToPBLink(emptyDirCid, dirname43, blockstore, options2)
+    cidToPBLink(emptyDirCid, dirname44, blockstore, options2)
   ]);
-  log16("adding empty dir called %s to %c", dirname43, parentCid);
+  log16("adding empty dir called %s to %c", dirname44, parentCid);
   const result = await addLink(directory, pblink, blockstore, {
     ...options2,
     allowOverwriting: options2.force
@@ -246632,8 +246964,8 @@ var init_unixfs2 = __esm({
       async *ls(cid, options2 = {}) {
         yield* ls(cid, this.components.blockstore, options2);
       }
-      async mkdir(cid, dirname43, options2 = {}) {
-        return mkdir6(cid, dirname43, this.components.blockstore, options2);
+      async mkdir(cid, dirname44, options2 = {}) {
+        return mkdir6(cid, dirname44, this.components.blockstore, options2);
       }
       async rm(cid, path12, options2 = {}) {
         return rm3(cid, path12, this.components.blockstore, options2);
@@ -250030,8 +250362,8 @@ var require_pattern = __commonJS({
     }
     exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
     function isAffectDepthOfReadingPattern(pattern) {
-      const basename34 = path12.basename(pattern);
-      return endsWithSlashGlobStar(pattern) || isStaticPattern(basename34);
+      const basename35 = path12.basename(pattern);
+      return endsWithSlashGlobStar(pattern) || isStaticPattern(basename35);
     }
     exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
     function expandPatternsWithBraceExpansion(patterns) {
@@ -253117,13 +253449,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash32 } = await import("node:crypto");
+          const { createHash: createHash34 } = await import("node:crypto");
           const snapshotDir = join32(this.cwd, ".omnius", "identity", "snapshots");
           await mkdir7(snapshotDir, { recursive: true });
           const version4 = this.selfState.version;
           const snapshotPath = join32(snapshotDir, `v${version4}.json`);
           await writeFile12(snapshotPath, snapshot, "utf8");
-          const hash = createHash32("sha256").update(snapshot).digest("hex");
+          const hash = createHash34("sha256").update(snapshot).digest("hex");
           await writeFile12(join32(this.cwd, ".omnius", "identity", "latest-hash.txt"), hash, "utf8");
           let ipfsCid = "";
           try {
@@ -253256,8 +253588,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash32 } = __require("node:crypto");
-        const machineId = createHash32("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash34 } = __require("node:crypto");
+        const machineId = createHash34("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `omnius-${machineId}`,
           version: 1,
@@ -253339,9 +253671,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash32 } = await import("node:crypto");
+            const { createHash: createHash34 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash = createHash32("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash = createHash34("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join32(this.cwd, ".omnius", "identity", "cids.json");
             const cidsData = { latest: "", hash, version: this.selfState.version };
             try {
@@ -262581,6 +262913,436 @@ ${llmAnnotation}` : result.llmContent;
   }
 });
 
+// packages/execution/dist/tools/sponsor-media.js
+import { createHash as createHash6 } from "node:crypto";
+function normalizeSponsorMediaConfig(value2) {
+  const input = typeof value2 === "object" && value2 !== null ? value2 : {};
+  const config = structuredClone(DEFAULT_SPONSOR_MEDIA_LIMITS);
+  for (const modality of SPONSOR_MEDIA_MODALITIES) {
+    const raw = input[modality];
+    if (!raw || typeof raw !== "object")
+      continue;
+    const src2 = raw;
+    const dst = config[modality];
+    dst.enabled = booleanValue(src2["enabled"], dst.enabled);
+    dst.allowedModels = normalizeAllowedModels(src2["allowedModels"] ?? src2["allowed_models"], dst.allowedModels);
+    dst.maxConcurrent = positiveInt(src2["maxConcurrent"] ?? src2["max_concurrent"], dst.maxConcurrent);
+    dst.jobsPerMinute = positiveInt(src2["jobsPerMinute"] ?? src2["jobs_per_minute"], dst.jobsPerMinute);
+    dst.jobsPerDay = positiveInt(src2["jobsPerDay"] ?? src2["jobs_per_day"], dst.jobsPerDay);
+    dst.maxOutputBytes = positiveInt(src2["maxOutputBytes"] ?? src2["max_output_bytes"], dst.maxOutputBytes);
+    dst.maxWidth = optionalPositiveInt(src2["maxWidth"] ?? src2["max_width"], dst.maxWidth);
+    dst.maxHeight = optionalPositiveInt(src2["maxHeight"] ?? src2["max_height"], dst.maxHeight);
+    dst.maxMegapixels = optionalPositiveNumber(src2["maxMegapixels"] ?? src2["max_megapixels"], dst.maxMegapixels);
+    dst.maxDurationSec = optionalPositiveNumber(src2["maxDurationSec"] ?? src2["max_duration_sec"], dst.maxDurationSec);
+    dst.maxFrames = optionalPositiveInt(src2["maxFrames"] ?? src2["max_frames"], dst.maxFrames);
+    dst.maxFps = optionalPositiveInt(src2["maxFps"] ?? src2["max_fps"], dst.maxFps);
+    dst.maxSteps = optionalPositiveInt(src2["maxSteps"] ?? src2["max_steps"], dst.maxSteps);
+  }
+  return config;
+}
+function sponsorMediaCapabilityName(modality, model = "auto") {
+  return `${SPONSOR_MEDIA_CAPABILITY_PREFIX}${modality}:${slugCapabilityPart(model || "auto")}`;
+}
+function parseSponsorMediaCapability(capability) {
+  const parts = capability.split(":");
+  if (parts.length < 3 || parts[0] !== "media")
+    return null;
+  const modality = parts[1];
+  if (!SPONSOR_MEDIA_MODALITIES.includes(modality))
+    return null;
+  return { modality, modelSlug: parts.slice(2).join(":") || "auto" };
+}
+function buildSponsorMediaServices(configLike) {
+  const config = normalizeSponsorMediaConfig(configLike);
+  const services = [];
+  for (const modality of SPONSOR_MEDIA_MODALITIES) {
+    const limits = config[modality];
+    if (!limits.enabled)
+      continue;
+    const models = limits.allowedModels === "all" || limits.allowedModels.length === 0 ? ["auto"] : limits.allowedModels;
+    for (const model of models) {
+      services.push({
+        kind: modality,
+        capability: sponsorMediaCapabilityName(modality, model),
+        model,
+        input: mediaInputsFor(modality),
+        output: mediaOutputsFor(modality),
+        limits: serializeMediaLimits(limits)
+      });
+    }
+  }
+  return services;
+}
+function sanitizeRemoteMediaGenerateRequest(input, service, configLike) {
+  const parsed = parseRemoteMediaRequest(input, service.kind);
+  if (!parsed.ok)
+    return parsed;
+  const req2 = parsed.value;
+  const config = normalizeSponsorMediaConfig(configLike);
+  const modality = req2.modality;
+  const limits = config[modality];
+  if (!limits.enabled)
+    return { ok: false, reason: `${modality} sponsorship is disabled` };
+  if (service.kind !== modality)
+    return { ok: false, reason: `Capability ${service.capability} cannot serve ${modality}` };
+  const options2 = req2.options && typeof req2.options === "object" ? { ...req2.options } : {};
+  for (const key of Object.keys(options2)) {
+    if (REMOTE_UNSAFE_KEYS.has(key)) {
+      return { ok: false, reason: `Remote media option '${key}' is not allowed` };
+    }
+  }
+  for (const key of LOCAL_PATH_INPUT_KEYS) {
+    const value2 = options2[key];
+    if (value2 === void 0)
+      continue;
+    if (typeof value2 !== "string")
+      return { ok: false, reason: `${key} must be a URL or uploaded artifact reference` };
+    if (!isSafeRemoteInputRef(value2)) {
+      return { ok: false, reason: `${key} cannot reference provider-local paths` };
+    }
+  }
+  if (Array.isArray(req2.inputs) && req2.inputs.length > 0) {
+    for (const remoteInput of req2.inputs) {
+      if (!remoteInput || typeof remoteInput !== "object")
+        return { ok: false, reason: "Invalid remote media input" };
+      if (!remoteInput.dataBase64 && !remoteInput.url)
+        return { ok: false, reason: "Remote media inputs require dataBase64 or url" };
+      if (remoteInput.url && !isSafeRemoteInputRef(remoteInput.url))
+        return { ok: false, reason: "Remote media input URL is not allowed" };
+    }
+  }
+  const requestedModel = req2.model || (typeof options2["model"] === "string" ? String(options2["model"]) : "");
+  const serviceModel = service.model && service.model !== "auto" ? service.model : "";
+  const model = serviceModel || requestedModel;
+  if (serviceModel && requestedModel && requestedModel !== serviceModel) {
+    return { ok: false, reason: `Capability ${service.capability} only serves model ${serviceModel}` };
+  }
+  if (model && limits.allowedModels !== "all" && !limits.allowedModels.includes(model)) {
+    return { ok: false, reason: `Model not allowed for ${modality}: ${model}` };
+  }
+  const args = {
+    ...options2,
+    prompt: req2.prompt,
+    action: "generate",
+    playback: false
+  };
+  if (model)
+    args["model"] = model;
+  if (req2.backend)
+    args["backend"] = req2.backend;
+  if (modality === "sound" || modality === "music")
+    args["kind"] = modality;
+  args["fallback"] = options2["fallback"] === false ? false : true;
+  const estimatedUnits = {
+    inputChars: req2.prompt.length
+  };
+  if (modality === "image") {
+    clampNumberArg(args, "width", limits.maxWidth);
+    clampNumberArg(args, "height", limits.maxHeight);
+    clampNumberArg(args, "steps", limits.maxSteps);
+    const width = numberFrom(args["width"]);
+    const height = numberFrom(args["height"]);
+    if (width && height && limits.maxMegapixels && width * height / 1e6 > limits.maxMegapixels) {
+      return { ok: false, reason: `Image exceeds ${limits.maxMegapixels} megapixels` };
+    }
+    if (width)
+      estimatedUnits.width = width;
+    if (height)
+      estimatedUnits.height = height;
+    const steps = numberFrom(args["steps"]);
+    if (steps)
+      estimatedUnits.steps = steps;
+  } else if (modality === "video") {
+    clampNumberArg(args, "width", limits.maxWidth);
+    clampNumberArg(args, "height", limits.maxHeight);
+    clampNumberArg(args, "duration_seconds", limits.maxDurationSec);
+    clampNumberArg(args, "num_frames", limits.maxFrames);
+    clampNumberArg(args, "fps", limits.maxFps);
+    clampNumberArg(args, "steps", limits.maxSteps);
+    const width = numberFrom(args["width"]);
+    const height = numberFrom(args["height"]);
+    if (width)
+      estimatedUnits.width = width;
+    if (height)
+      estimatedUnits.height = height;
+    const durationSec = numberFrom(args["duration_seconds"]);
+    if (durationSec)
+      estimatedUnits.durationSec = durationSec;
+    const frames = numberFrom(args["num_frames"]);
+    if (frames)
+      estimatedUnits.frames = frames;
+    const fps = numberFrom(args["fps"]);
+    if (fps)
+      estimatedUnits.fps = fps;
+    const steps = numberFrom(args["steps"]);
+    if (steps)
+      estimatedUnits.steps = steps;
+  } else {
+    clampNumberArg(args, "duration", limits.maxDurationSec);
+    clampNumberArg(args, "steps", limits.maxSteps);
+    const durationSec = numberFrom(args["duration"]);
+    if (durationSec)
+      estimatedUnits.durationSec = durationSec;
+    const steps = numberFrom(args["steps"]);
+    if (steps)
+      estimatedUnits.steps = steps;
+  }
+  return { ok: true, value: { args, estimatedUnits } };
+}
+function artifactManifestFromBytes(args) {
+  const hash = createHash6("sha256").update(args.bytes).digest("hex");
+  return {
+    artifactId: args.artifactId,
+    filename: args.filename,
+    mime: args.mime,
+    sizeBytes: args.bytes.byteLength,
+    sha256: hash
+  };
+}
+function mediaMimeFromPath(path12, modality) {
+  const lc = path12.toLowerCase();
+  if (lc.endsWith(".png"))
+    return "image/png";
+  if (lc.endsWith(".jpg") || lc.endsWith(".jpeg"))
+    return "image/jpeg";
+  if (lc.endsWith(".webp"))
+    return "image/webp";
+  if (lc.endsWith(".mp4"))
+    return "video/mp4";
+  if (lc.endsWith(".webm"))
+    return "video/webm";
+  if (lc.endsWith(".wav"))
+    return "audio/wav";
+  if (lc.endsWith(".mp3"))
+    return "audio/mpeg";
+  if (modality === "image")
+    return "image/png";
+  if (modality === "video")
+    return "video/mp4";
+  return "audio/wav";
+}
+function defaultExtensionForMime(mime) {
+  if (mime === "image/png")
+    return ".png";
+  if (mime === "image/jpeg")
+    return ".jpg";
+  if (mime === "image/webp")
+    return ".webp";
+  if (mime === "video/mp4")
+    return ".mp4";
+  if (mime === "video/webm")
+    return ".webm";
+  if (mime === "audio/mpeg")
+    return ".mp3";
+  if (mime === "audio/wav" || mime === "audio/x-wav")
+    return ".wav";
+  return ".bin";
+}
+function parseRemoteMediaRequest(input, fallbackModality) {
+  let raw = input;
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch {
+      raw = { prompt: raw };
+    }
+  }
+  if (!raw || typeof raw !== "object")
+    return { ok: false, reason: "Remote media request must be an object" };
+  const obj = raw;
+  const prompt = String(obj["prompt"] ?? "").trim();
+  if (!prompt)
+    return { ok: false, reason: "Remote media prompt is required" };
+  const modality = String(obj["modality"] ?? fallbackModality);
+  if (!SPONSOR_MEDIA_MODALITIES.includes(modality))
+    return { ok: false, reason: `Unsupported media modality: ${String(obj["modality"])}` };
+  return {
+    ok: true,
+    value: {
+      modality,
+      prompt,
+      model: typeof obj["model"] === "string" && obj["model"].trim() ? obj["model"].trim() : void 0,
+      backend: typeof obj["backend"] === "string" && obj["backend"].trim() ? obj["backend"].trim() : void 0,
+      options: obj["options"] && typeof obj["options"] === "object" ? obj["options"] : void 0,
+      inputs: Array.isArray(obj["inputs"]) ? obj["inputs"] : void 0,
+      auth_key: typeof obj["auth_key"] === "string" ? obj["auth_key"] : void 0
+    }
+  };
+}
+function serializeMediaLimits(limits) {
+  return {
+    enabled: limits.enabled,
+    allowedModels: limits.allowedModels,
+    maxConcurrent: limits.maxConcurrent,
+    jobsPerMinute: limits.jobsPerMinute,
+    jobsPerDay: limits.jobsPerDay,
+    maxOutputBytes: limits.maxOutputBytes,
+    ...limits.maxWidth !== void 0 ? { maxWidth: limits.maxWidth } : {},
+    ...limits.maxHeight !== void 0 ? { maxHeight: limits.maxHeight } : {},
+    ...limits.maxMegapixels !== void 0 ? { maxMegapixels: limits.maxMegapixels } : {},
+    ...limits.maxDurationSec !== void 0 ? { maxDurationSec: limits.maxDurationSec } : {},
+    ...limits.maxFrames !== void 0 ? { maxFrames: limits.maxFrames } : {},
+    ...limits.maxFps !== void 0 ? { maxFps: limits.maxFps } : {},
+    ...limits.maxSteps !== void 0 ? { maxSteps: limits.maxSteps } : {}
+  };
+}
+function mediaInputsFor(modality) {
+  if (modality === "image")
+    return ["prompt"];
+  if (modality === "video")
+    return ["prompt", "image", "audio_input"];
+  return ["prompt"];
+}
+function mediaOutputsFor(modality) {
+  if (modality === "image")
+    return ["image/png", "image/jpeg", "image/webp"];
+  if (modality === "video")
+    return ["video/mp4"];
+  return ["audio/wav", "audio/mpeg"];
+}
+function slugCapabilityPart(value2) {
+  const slug = value2.trim().replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+|_+$/g, "");
+  return slug || "auto";
+}
+function booleanValue(value2, fallback) {
+  if (typeof value2 === "boolean")
+    return value2;
+  if (typeof value2 === "string")
+    return /^(1|true|yes|on)$/i.test(value2.trim());
+  return fallback;
+}
+function positiveInt(value2, fallback) {
+  const n2 = Number(value2);
+  return Number.isFinite(n2) && n2 > 0 ? Math.floor(n2) : fallback;
+}
+function optionalPositiveInt(value2, fallback) {
+  if (value2 === void 0 || value2 === null || value2 === "")
+    return fallback;
+  const n2 = Number(value2);
+  return Number.isFinite(n2) && n2 > 0 ? Math.floor(n2) : fallback;
+}
+function optionalPositiveNumber(value2, fallback) {
+  if (value2 === void 0 || value2 === null || value2 === "")
+    return fallback;
+  const n2 = Number(value2);
+  return Number.isFinite(n2) && n2 > 0 ? n2 : fallback;
+}
+function normalizeAllowedModels(value2, fallback) {
+  if (value2 === "all")
+    return "all";
+  if (Array.isArray(value2)) {
+    const models = value2.map((item) => String(item).trim()).filter(Boolean);
+    return models.length > 0 ? [...new Set(models)] : fallback;
+  }
+  if (typeof value2 === "string" && value2.trim()) {
+    const raw = value2.trim();
+    if (raw === "all")
+      return "all";
+    const models = raw.split(",").map((item) => item.trim()).filter(Boolean);
+    return models.length > 0 ? [...new Set(models)] : fallback;
+  }
+  return fallback;
+}
+function clampNumberArg(args, key, max) {
+  if (max === void 0)
+    return;
+  const value2 = numberFrom(args[key]);
+  if (value2 === void 0)
+    return;
+  args[key] = Math.min(value2, max);
+}
+function numberFrom(value2) {
+  const n2 = Number(value2);
+  return Number.isFinite(n2) && n2 > 0 ? n2 : void 0;
+}
+function isSafeRemoteInputRef(value2) {
+  const raw = value2.trim();
+  if (!raw)
+    return false;
+  if (/^https?:\/\//i.test(raw))
+    return true;
+  if (/^data:[a-z0-9.+/-]+;base64,/i.test(raw))
+    return true;
+  if (/^artifact:[a-zA-Z0-9._:-]+$/.test(raw))
+    return true;
+  return false;
+}
+var SPONSOR_MEDIA_MODALITIES, SPONSOR_MEDIA_CAPABILITY_PREFIX, DEFAULT_SPONSOR_MEDIA_LIMITS, REMOTE_UNSAFE_KEYS, LOCAL_PATH_INPUT_KEYS;
+var init_sponsor_media = __esm({
+  "packages/execution/dist/tools/sponsor-media.js"() {
+    "use strict";
+    SPONSOR_MEDIA_MODALITIES = ["image", "video", "sound", "music"];
+    SPONSOR_MEDIA_CAPABILITY_PREFIX = "media:";
+    DEFAULT_SPONSOR_MEDIA_LIMITS = {
+      image: {
+        enabled: false,
+        allowedModels: "all",
+        maxConcurrent: 1,
+        jobsPerMinute: 6,
+        jobsPerDay: 60,
+        maxOutputBytes: 25 * 1024 * 1024,
+        maxWidth: 1024,
+        maxHeight: 1024,
+        maxMegapixels: 1.25,
+        maxSteps: 40
+      },
+      video: {
+        enabled: false,
+        allowedModels: "all",
+        maxConcurrent: 1,
+        jobsPerMinute: 2,
+        jobsPerDay: 12,
+        maxOutputBytes: 250 * 1024 * 1024,
+        maxWidth: 1280,
+        maxHeight: 720,
+        maxDurationSec: 8,
+        maxFrames: 129,
+        maxFps: 24,
+        maxSteps: 50
+      },
+      sound: {
+        enabled: false,
+        allowedModels: "all",
+        maxConcurrent: 1,
+        jobsPerMinute: 4,
+        jobsPerDay: 40,
+        maxOutputBytes: 50 * 1024 * 1024,
+        maxDurationSec: 15,
+        maxSteps: 50
+      },
+      music: {
+        enabled: false,
+        allowedModels: "all",
+        maxConcurrent: 1,
+        jobsPerMinute: 2,
+        jobsPerDay: 20,
+        maxOutputBytes: 80 * 1024 * 1024,
+        maxDurationSec: 30,
+        maxSteps: 80
+      }
+    };
+    REMOTE_UNSAFE_KEYS = /* @__PURE__ */ new Set([
+      "action",
+      "setup",
+      "prewarm",
+      "prepare",
+      "pull",
+      "python",
+      "hf_token",
+      "model_path",
+      "playback"
+    ]);
+    LOCAL_PATH_INPUT_KEYS = /* @__PURE__ */ new Set([
+      "image",
+      "image_path",
+      "init_image",
+      "source_image",
+      "reference_image",
+      "audio_input"
+    ]);
+  }
+});
+
 // packages/execution/dist/tools/structured-read.js
 import { readFile as readFile15, stat as stat5 } from "node:fs/promises";
 import { resolve as resolve21, extname as extname5 } from "node:path";
@@ -265923,7 +266685,7 @@ import { execSync as execSync23, exec as execCb, spawnSync as spawnSync4 } from
 import { readFile as readFile16, writeFile as writeFile20, mkdir as mkdir15 } from "node:fs/promises";
 import { resolve as resolve28, join as join48 } from "node:path";
 import { homedir as homedir13 } from "node:os";
-import { randomBytes as randomBytes12, createHash as createHash6 } from "node:crypto";
+import { randomBytes as randomBytes12, createHash as createHash7 } from "node:crypto";
 function isValidCron(expr) {
   const parts = expr.trim().split(/\s+/);
   if (parts.length !== 5)
@@ -266359,7 +267121,7 @@ var init_scheduler = __esm({
         }
         const scope = String(args["scope"] ?? "local");
         const fingerprint = `${resolve28(this.workingDir)}|${task}|${cronExpr}|${scope}`;
-        const id = `sched-${createHash6("sha1").update(fingerprint).digest("hex").slice(0, 8)}`;
+        const id = `sched-${createHash7("sha1").update(fingerprint).digest("hex").slice(0, 8)}`;
         const oneShot = Boolean(args["one_shot"]);
         const maxRuns = typeof args["max_runs"] === "number" ? args["max_runs"] : void 0;
         const newTask = {
@@ -270515,7 +271277,7 @@ var init_import_graph = __esm({
 import { createRequire as __createRequireGlob } from "node:module";
 import ignore from "ignore";
 import { readFile as readFile21, stat as stat6 } from "node:fs/promises";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { join as join56, relative as relative5, extname as extname8, basename as basename13 } from "node:path";
 var __requireGlob, glob2, DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
@@ -270583,7 +271345,7 @@ var init_codebase_indexer = __esm({
             if (fileStat.size > this.config.maxFileSize)
               continue;
             const content = await readFile21(fullPath);
-            const hash = createHash7("sha256").update(content).digest("hex");
+            const hash = createHash8("sha256").update(content).digest("hex");
             const ext = extname8(relativePath);
             indexed.push({
               path: fullPath,
@@ -410087,9 +410849,9 @@ ${lanes.join("\n")}
             /*ignoreCase*/
             false
           )) {
-            const basename34 = getBaseFileName(a2.fileName);
-            if (basename34 === "lib.d.ts" || basename34 === "lib.es6.d.ts") return 0;
-            const name10 = removeSuffix(removePrefix(basename34, "lib."), ".d.ts");
+            const basename35 = getBaseFileName(a2.fileName);
+            if (basename35 === "lib.d.ts" || basename35 === "lib.es6.d.ts") return 0;
+            const name10 = removeSuffix(removePrefix(basename35, "lib."), ".d.ts");
             const index = libs.indexOf(name10);
             if (index !== -1) return index + 1;
           }
@@ -474015,8 +474777,8 @@ ${options2.prefix}` : "\n" : options2.prefix
             }
           };
           for (const file of files) {
-            const basename34 = getBaseFileName(file);
-            if (basename34 === "package.json" || basename34 === "bower.json") {
+            const basename35 = getBaseFileName(file);
+            if (basename35 === "package.json" || basename35 === "bower.json") {
               createProjectWatcher(
                 file,
                 "FileWatcher"
@@ -477700,8 +478462,8 @@ All files are: ${JSON.stringify(names)}`,
               var _a;
               const fileOrDirectoryPath = removeIgnoredPath(this.toPath(fileOrDirectory));
               if (!fileOrDirectoryPath) return;
-              const basename34 = getBaseFileName(fileOrDirectoryPath);
-              if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename34 === "package.json" || basename34 === "node_modules")) {
+              const basename35 = getBaseFileName(fileOrDirectoryPath);
+              if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename35 === "package.json" || basename35 === "node_modules")) {
                 result.affectedModuleSpecifierCacheProjects.forEach((project) => {
                   var _a2;
                   (_a2 = project.getModuleSpecifierCache()) == null ? void 0 : _a2.clear();
@@ -486582,7 +487344,7 @@ var require_path_browserify = __commonJS({
       _makeLong: function _makeLong(path12) {
         return path12;
       },
-      dirname: function dirname43(path12) {
+      dirname: function dirname44(path12) {
         assertPath(path12);
         if (path12.length === 0) return ".";
         var code8 = path12.charCodeAt(0);
@@ -486604,7 +487366,7 @@ var require_path_browserify = __commonJS({
         if (hasRoot && end === 1) return "//";
         return path12.slice(0, end);
       },
-      basename: function basename34(path12, ext) {
+      basename: function basename35(path12, ext) {
         if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
         assertPath(path12);
         var start2 = 0;
@@ -514895,7 +515657,7 @@ var init_ts_morph_parser = __esm({
 
 // packages/indexer/dist/code-graph-db.js
 import { createRequire as createRequire2 } from "node:module";
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { mkdirSync as mkdirSync16, readFileSync as readFileSync30 } from "node:fs";
 import { join as join57, dirname as dirname14, extname as extname9 } from "node:path";
 function loadDatabaseCtor() {
@@ -514967,7 +515729,7 @@ function extractFileImports(content, filePath) {
   return imports.map((p2) => p2.replace(/\.(js|ts|jsx|tsx|mjs|cjs)$/, ""));
 }
 function hashContent(content) {
-  return createHash8("sha1").update(content).digest("hex").slice(0, 16);
+  return createHash9("sha1").update(content).digest("hex").slice(0, 16);
 }
 function detectLanguage(filePath) {
   return EXT_TO_LANG[extname9(filePath)] ?? "unknown";
@@ -523476,7 +524238,7 @@ var init_client3 = __esm({
 import { existsSync as existsSync53, readFileSync as readFileSync39, writeFileSync as writeFileSync24, mkdirSync as mkdirSync27, chmodSync, statSync as statSync24 } from "node:fs";
 import { join as join69, dirname as dirname16 } from "node:path";
 import { homedir as homedir22 } from "node:os";
-import { randomBytes as randomBytes18, createHash as createHash9 } from "node:crypto";
+import { randomBytes as randomBytes18, createHash as createHash10 } from "node:crypto";
 function secretsPath(scope, repoRoot) {
   return scope === "global" ? join69(homedir22(), ".omnius", "secrets.json") : join69(repoRoot, ".omnius", "secrets.json");
 }
@@ -523517,7 +524279,7 @@ function sanitizeHint(hint) {
   return hint.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 32) || "GENERIC";
 }
 function shortDigest(value2) {
-  return createHash9("sha256").update(value2).digest("hex").slice(0, 6);
+  return createHash10("sha256").update(value2).digest("hex").slice(0, 6);
 }
 function randomSuffix() {
   return randomBytes18(3).toString("hex");
@@ -525213,7 +525975,7 @@ var init_environment_snapshot = __esm({
 import { execSync as execSync43 } from "node:child_process";
 import { existsSync as existsSync57, mkdirSync as mkdirSync29, writeFileSync as writeFileSync27, readFileSync as readFileSync43, readdirSync as readdirSync20, unlinkSync as unlinkSync12 } from "node:fs";
 import { join as join72, basename as basename15 } from "node:path";
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 function isYouTubeUrl2(url) {
   return /(?:youtube\.com\/(?:watch|shorts|live|embed|v\/)|youtu\.be\/)/i.test(url);
 }
@@ -525241,7 +526003,7 @@ function ensureFfmpeg() {
 function imageHash(imagePath) {
   try {
     const data = readFileSync43(imagePath);
-    return createHash10("md5").update(data).digest("hex").slice(0, 12);
+    return createHash11("md5").update(data).digest("hex").slice(0, 12);
   } catch {
     return "unknown";
   }
@@ -526897,6 +527659,7 @@ __export(dist_exports, {
   DEFAULT_MUSIC_MODEL: () => DEFAULT_MUSIC_MODEL,
   DEFAULT_OLLAMA_IMAGE_MODEL: () => DEFAULT_OLLAMA_IMAGE_MODEL,
   DEFAULT_SOUND_MODEL: () => DEFAULT_SOUND_MODEL,
+  DEFAULT_SPONSOR_MEDIA_LIMITS: () => DEFAULT_SPONSOR_MEDIA_LIMITS,
   DESKTOP_DEPS: () => DESKTOP_DEPS,
   DebateTool: () => DebateTool,
   DesktopClickTool: () => DesktopClickTool,
@@ -526959,6 +527722,8 @@ __export(dist_exports, {
   ReplTool: () => ReplTool,
   ReplayWithInterventionTool: () => ReplayWithInterventionTool,
   RepoMapTool: () => RepoMapTool,
+  SPONSOR_MEDIA_CAPABILITY_PREFIX: () => SPONSOR_MEDIA_CAPABILITY_PREFIX,
+  SPONSOR_MEDIA_MODALITIES: () => SPONSOR_MEDIA_MODALITIES,
   SchedulerTool: () => SchedulerTool,
   ScreenshotTool: () => ScreenshotTool,
   SdrScanTool: () => SdrScanTool,
@@ -527005,6 +527770,7 @@ __export(dist_exports, {
   aliasTool: () => aliasTool,
   applyPatch: () => applyPatch,
   applyToolResultTriage: () => applyToolResultTriage,
+  artifactManifestFromBytes: () => artifactManifestFromBytes,
   audioGenerationDir: () => audioGenerationDir,
   audioGenerationSetupPlan: () => audioGenerationSetupPlan,
   audioGenerationVenvDir: () => audioGenerationVenvDir,
@@ -527018,6 +527784,7 @@ __export(dist_exports, {
   buildMcpToolName: () => buildMcpToolName,
   buildScaffoldedPrompt: () => buildScaffoldedPrompt,
   buildSkillsSummary: () => buildSkillsSummary,
+  buildSponsorMediaServices: () => buildSponsorMediaServices,
   buildSubProcessArgs: () => buildSubProcessArgs,
   buildToolManifestFromModule: () => buildToolManifestFromModule,
   canInvokeTool: () => canInvokeTool,
@@ -527037,6 +527804,7 @@ __export(dist_exports, {
   createTransport: () => createTransport,
   createWorktree: () => createWorktree2,
   defaultExposureForTool: () => defaultExposureForTool,
+  defaultExtensionForMime: () => defaultExtensionForMime,
   deleteTodos: () => deleteTodos,
   detectElevationMethod: () => detectElevationMethod,
   detectLegacyCaches: () => detectLegacyCaches,
@@ -527128,14 +527896,17 @@ __export(dist_exports, {
   markReverted: () => markReverted,
   markSessionValidated: () => markSessionValidated,
   measureRepoCacheBytes: () => measureRepoCacheBytes,
+  mediaMimeFromPath: () => mediaMimeFromPath,
   migrateLegacyCaches: () => migrateLegacyCaches,
   networkEgressErrorMessage: () => networkEgressErrorMessage,
   normalizeMcpName: () => normalizeMcpName,
   normalizeNetworkHostname: () => normalizeNetworkHostname,
+  normalizeSponsorMediaConfig: () => normalizeSponsorMediaConfig,
   omniusHomeDir: () => omniusHomeDir,
   packetPath: () => packetPath,
   parseMcpMarkdown: () => parseMcpMarkdown,
   parseMcpToolName: () => parseMcpToolName,
+  parseSponsorMediaCapability: () => parseSponsorMediaCapability,
   playSoundFile: () => playSoundFile,
   promoteWorkingNotes: () => promoteWorkingNotes,
   quarantineSecret: () => quarantineSecret,
@@ -527166,6 +527937,7 @@ __export(dist_exports, {
   runTypecheck: () => runTypecheck,
   runValidationPipeline: () => runValidationPipeline,
   sanitizeReminderDeliveryText: () => sanitizeReminderDeliveryText,
+  sanitizeRemoteMediaGenerateRequest: () => sanitizeRemoteMediaGenerateRequest,
   saveCustomToolDefinition: () => saveCustomToolDefinition,
   saveMcpServerToConfig: () => saveMcpServerToConfig,
   savePacket: () => savePacket,
@@ -527179,6 +527951,7 @@ __export(dist_exports, {
   sha256Text: () => sha256Text,
   shannonEntropy: () => shannonEntropy,
   spawnFullSubAgent: () => spawnFullSubAgent,
+  sponsorMediaCapabilityName: () => sponsorMediaCapabilityName,
   stableJson: () => stableJson,
   stopFullSubAgent: () => stopFullSubAgent,
   summarizeLog: () => summarizeLog,
@@ -527266,6 +528039,7 @@ var init_dist5 = __esm({
     init_audio_generate();
     init_model_store();
     init_video_generate();
+    init_sponsor_media();
     init_structured_read();
     init_vision();
     init_desktop_click();
@@ -531825,14 +532599,14 @@ var init_artifact_inspector = __esm({
 // packages/orchestrator/dist/lesson-bank.js
 import { existsSync as existsSync66, mkdirSync as mkdirSync32, appendFileSync as appendFileSync2, readFileSync as readFileSync51 } from "node:fs";
 import { join as join79, dirname as dirname22 } from "node:path";
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function tokenize2(text) {
   if (!text)
     return [];
   return text.toLowerCase().split(TOKENIZE_RE).filter((t2) => t2.length >= 3).slice(0, 80);
 }
 function shortHash(s2) {
-  return createHash11("sha256").update(s2).digest("hex").slice(0, 16);
+  return createHash12("sha256").update(s2).digest("hex").slice(0, 16);
 }
 function solicit(args) {
   const { taskGoal, stem, reflections, successOutputPreview } = args;
@@ -535457,7 +536231,7 @@ var init_pprRetrieval = __esm({
 import { join as join85 } from "node:path";
 import { mkdirSync as mkdirSync34, existsSync as existsSync72 } from "node:fs";
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 function readEpisodeAffect2(metadata) {
   if (!metadata || typeof metadata !== "object")
     return null;
@@ -535675,7 +536449,7 @@ var init_episodeStore = __esm({
       insert(ep) {
         const id = randomUUID8();
         const now = Date.now();
-        const contentHash2 = createHash12("sha256").update(ep.content).digest("hex").slice(0, 16);
+        const contentHash2 = createHash13("sha256").update(ep.content).digest("hex").slice(0, 16);
         const modality = ep.modality ?? "text";
         const rawImportance = ep.importance ?? autoImportance(ep.toolName ?? null, modality, ep.content);
         const modulated = ep.emotionalState ? modulateImportance(sanitizeImportance(rawImportance), ep.emotionalState) : sanitizeImportance(rawImportance);
@@ -536209,9 +536983,9 @@ var init_temporalGraph = __esm({
 });
 
 // packages/memory/dist/multimodalIdentity.js
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 function stableHash(value2) {
-  return createHash13("sha256").update(value2).digest("hex").slice(0, 24);
+  return createHash14("sha256").update(value2).digest("hex").slice(0, 24);
 }
 function normalizeAtom(value2) {
   return value2.trim().toLowerCase().replace(/\s+/g, " ");
@@ -536568,9 +537342,9 @@ var init_gistCompressor = __esm({
 });
 
 // packages/memory/dist/graphWalk.js
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function seededUnit(seed) {
-  const digest3 = createHash14("sha256").update(seed || "graph-walk").digest();
+  const digest3 = createHash15("sha256").update(seed || "graph-walk").digest();
   const value2 = digest3.readUInt32BE(0);
   return value2 / 4294967295;
 }
@@ -540701,7 +541475,7 @@ var init_memoryStageContext = __esm({
 });
 
 // packages/memory/dist/sessionGist.js
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 function inferDomain(input) {
   const blob = [
     input.goal,
@@ -540726,7 +541500,7 @@ function inferDomain(input) {
   return ranked[0][0];
 }
 function computeGoalHash(goal) {
-  return createHash15("sha256").update(goal.trim().toLowerCase()).digest("hex").slice(0, 16);
+  return createHash16("sha256").update(goal.trim().toLowerCase()).digest("hex").slice(0, 16);
 }
 function clip(text, n2) {
   if (!text)
@@ -540937,12 +541711,12 @@ var init_toolOutcomes = __esm({
 });
 
 // packages/memory/dist/stagnationRecipes.js
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 function fingerprintSignature(fp) {
   const normClusters = (fp.errorClusters ?? []).map((s2) => (s2 || "").toLowerCase().replace(/[0-9]+/g, "N").replace(/\s+/g, " ").trim()).filter(Boolean).sort();
   const tool = (fp.stuckTool ?? "").toLowerCase().trim();
   const blob = `tool=${tool};clusters=${normClusters.join("|")}`;
-  return createHash16("sha256").update(blob).digest("hex").slice(0, 16);
+  return createHash17("sha256").update(blob).digest("hex").slice(0, 16);
 }
 function crystallize(store2, input) {
   const sig = fingerprintSignature(input.fingerprint);
@@ -540999,7 +541773,7 @@ var init_stagnationRecipes = __esm({
 });
 
 // packages/memory/dist/codebaseMap.js
-import { createHash as createHash17, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash18, randomUUID as randomUUID12 } from "node:crypto";
 function freshNodeId() {
   return randomUUID12();
 }
@@ -541013,7 +541787,7 @@ var init_codebaseMap = __esm({
       touchCount = /* @__PURE__ */ new Map();
       constructor(db, repoRoot, commitSha) {
         this.db = db;
-        this.repoFp = createHash17("sha256").update(`${repoRoot}::${commitSha ?? "no-commit"}`).digest("hex").slice(0, 16);
+        this.repoFp = createHash18("sha256").update(`${repoRoot}::${commitSha ?? "no-commit"}`).digest("hex").slice(0, 16);
         this.ensureSchema();
       }
       ensureSchema() {
@@ -541195,7 +541969,7 @@ var init_codebaseMap = __esm({
       }
       /** Stable composite id: `<kind>:<sha16(path)>` so insert ON CONFLICT works. */
       idFor(kind, path12) {
-        const h = createHash17("sha256").update(`${this.repoFp}:${kind}:${path12}`).digest("hex").slice(0, 24);
+        const h = createHash18("sha256").update(`${this.repoFp}:${kind}:${path12}`).digest("hex").slice(0, 24);
         return `${kind}-${h}`;
       }
     };
@@ -543706,7 +544480,7 @@ import { existsSync as existsSync80, readFileSync as readFileSync62, statSync as
 import { execSync as execSync46 } from "node:child_process";
 import { homedir as homedir29, platform as platform3, arch as arch2, totalmem as totalmem3, freemem as freemem3, hostname as hostname3 } from "node:os";
 import { join as join93 } from "node:path";
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function capturePreflightSnapshot(workingDir) {
   const warnings = [];
   const configFingerprints = {};
@@ -543873,7 +544647,7 @@ function expandPath(p2) {
   return p2;
 }
 function sha2563(s2) {
-  return createHash18("sha256").update(s2).digest("hex").slice(0, 16);
+  return createHash19("sha256").update(s2).digest("hex").slice(0, 16);
 }
 function freeDiskBytes(path12 = "/tmp") {
   try {
@@ -550135,8 +550909,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               if (process.env["OMNIUS_DISABLE_ADAPTIVE_RETRIEVAL"] !== "1") {
                 const goalForSig = (this._taskState.goal || "").slice(0, 200);
                 const recentTools = this._toolSequence.slice(-5).join("|");
-                const { createHash: createHash32 } = await import("node:crypto");
-                const sig = createHash32("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
+                const { createHash: createHash34 } = await import("node:crypto");
+                const sig = createHash34("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
                 if (this._lastPprSig === sig && this._lastPprMemoryLines.length > 0) {
                   compacted.push({
                     role: "system",
@@ -563592,10 +564366,10 @@ transcribe-cli error: ${transcribeCliError}` : "";
               wordTimestamps: false
             });
             if (outputDir) {
-              const { basename: basename34 } = await import("node:path");
+              const { basename: basename35 } = await import("node:path");
               const transcriptDir = join102(outputDir, ".omnius", "transcripts");
               mkdirSync48(transcriptDir, { recursive: true });
-              const outFile = join102(transcriptDir, `${basename34(filePath)}.txt`);
+              const outFile = join102(transcriptDir, `${basename35(filePath)}.txt`);
               writeFileSync43(outFile, result.text, "utf-8");
             }
             return {
@@ -563611,10 +564385,10 @@ transcribe-cli error: ${transcribeCliError}` : "";
         const fb = await transcribeFileViaWhisper(filePath, this.config.model);
         if (fb) {
           if (outputDir) {
-            const { basename: basename34 } = await import("node:path");
+            const { basename: basename35 } = await import("node:path");
             const transcriptDir = join102(outputDir, ".omnius", "transcripts");
             mkdirSync48(transcriptDir, { recursive: true });
-            const outFile = join102(transcriptDir, `${basename34(filePath)}.txt`);
+            const outFile = join102(transcriptDir, `${basename35(filePath)}.txt`);
             writeFileSync43(outFile, fb.text, "utf-8");
           }
           return fb;
@@ -565862,7 +566636,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes29, createHash: createHash32 } = __require("crypto");
+    var { randomBytes: randomBytes29, createHash: createHash34 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate3();
@@ -566522,7 +567296,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash32("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash34("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -566889,7 +567663,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash32 } = __require("crypto");
+    var { createHash: createHash34 } = __require("crypto");
     var extension3 = require_extension3();
     var PerMessageDeflate3 = require_permessage_deflate3();
     var subprotocol3 = require_subprotocol2();
@@ -567190,7 +567964,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash32("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash34("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -567943,6 +568717,10 @@ var init_command_registry = __esm({
       ["/ipfs import <cid>", "Import a shared IPFS tool or skill reference"],
       ["/sponsor", "Sponsor inference - onboarding wizard or dashboard"],
       ["/sponsor status", "Show sponsor dashboard with usage metrics"],
+      ["/sponsor image <prompt>", "Generate an image on a sponsored peer"],
+      ["/sponsor video <prompt>", "Generate a video on a sponsored peer"],
+      ["/sponsor sound <prompt>", "Generate a sound effect on a sponsored peer"],
+      ["/sponsor music <prompt>", "Generate music on a sponsored peer"],
       ["/sponsor pause", "Pause active sponsorship"],
       ["/sponsor remove", "Remove sponsorship entirely"],
       ["/endpoint sponsor", "Browse and connect to sponsored inference from the nexus mesh"],
@@ -571976,14 +572754,14 @@ var init_voice_session = __esm({
 });
 
 // packages/cli/src/tui/scoped-personality.ts
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 import { appendFileSync as appendFileSync5, existsSync as existsSync88, mkdirSync as mkdirSync49, readFileSync as readFileSync69, writeFileSync as writeFileSync44 } from "node:fs";
 import { join as join103, resolve as resolve39 } from "node:path";
 function safeName(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
 }
 function scopeHash(scope) {
-  return createHash19("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash20("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function scopedPersonalityDir(repoRoot, kind) {
   return resolve39(repoRoot, ".omnius", "scoped-personality", kind);
@@ -572314,7 +573092,7 @@ var init_scoped_personality = __esm({
 });
 
 // packages/cli/src/tui/voice-soul.ts
-import { createHash as createHash20 } from "node:crypto";
+import { createHash as createHash21 } from "node:crypto";
 import { existsSync as existsSync89, readdirSync as readdirSync29, readFileSync as readFileSync70 } from "node:fs";
 import { basename as basename20, join as join104, resolve as resolve40 } from "node:path";
 function compactText(text, limit) {
@@ -572329,7 +573107,7 @@ function blockText(text, limit) {
 ... [truncated]`;
 }
 function scopeStateKey(scope, surface) {
-  return createHash20("sha1").update(`${surface}:${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash21("sha1").update(`${surface}:${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function safeName2(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
@@ -572857,6 +573635,26 @@ function serializeSponsorModels(stats) {
     (a2, b) => (b.tokensIn + b.tokensOut || b.requests) - (a2.tokensIn + a2.tokensOut || a2.requests)
   );
 }
+function parseMediaUsageKey(key) {
+  const [rawModality, ...modelParts] = key.split(":");
+  const modality = SPONSOR_MEDIA_MODALITIES.includes(rawModality) ? rawModality : "image";
+  return { modality, model: modelParts.join(":") || "auto" };
+}
+function serializeSponsorMedia(stats) {
+  return Array.from(stats.mediaUsage.entries()).map(([key, meter]) => {
+    const parsed = parseMediaUsageKey(key);
+    return {
+      key,
+      modality: parsed.modality,
+      model: parsed.model,
+      jobs: meter.jobs,
+      bytesOut: meter.bytesOut,
+      failures: meter.failures,
+      avgLatencyMs: meter.jobs > 0 ? Math.round(meter.totalLatencyMs / meter.jobs) : 0,
+      lastUsed: meter.lastUsed
+    };
+  }).sort((a2, b) => (b.jobs || b.bytesOut) - (a2.jobs || a2.bytesOut));
+}
 function serializeSponsorPeers(stats) {
   return Array.from(stats.users.values()).map((user) => ({
     peer: user.ip,
@@ -572872,7 +573670,20 @@ function serializeSponsorPeers(stats) {
       tokensIn: meter.tokensIn,
       tokensOut: meter.tokensOut,
       lastUsed: meter.lastUsed
-    })).sort((a2, b) => b.tokensIn + b.tokensOut - (a2.tokensIn + a2.tokensOut))
+    })).sort((a2, b) => b.tokensIn + b.tokensOut - (a2.tokensIn + a2.tokensOut)),
+    media: Array.from(user.media.entries()).map(([key, meter]) => {
+      const parsed = parseMediaUsageKey(key);
+      return {
+        key,
+        modality: parsed.modality,
+        model: parsed.model,
+        jobs: meter.jobs,
+        bytesOut: meter.bytesOut,
+        failures: meter.failures,
+        avgLatencyMs: meter.jobs > 0 ? Math.round(meter.totalLatencyMs / meter.jobs) : 0,
+        lastUsed: meter.lastUsed
+      };
+    }).sort((a2, b) => (b.jobs || b.bytesOut) - (a2.jobs || a2.bytesOut))
   })).sort((a2, b) => (b.tokensIn + b.tokensOut || b.requests) - (a2.tokensIn + a2.tokensOut || a2.requests));
 }
 function nextSponsorDailyReset(now = Date.now()) {
@@ -573070,6 +573881,7 @@ var HOP_BY_HOP_HEADERS, CF_HEADERS_PREFIX, DEFAULT_EXPOSE_MAX_BODY_BYTES, INTERN
 var init_expose = __esm({
   "packages/cli/src/tui/expose.ts"() {
     "use strict";
+    init_dist5();
     init_render();
     init_usage_bars();
     init_typed_node_events();
@@ -573155,6 +573967,7 @@ var init_expose = __esm({
         tokensPerSecond: 0,
         startedAt: Date.now(),
         modelUsage: /* @__PURE__ */ new Map(),
+        mediaUsage: /* @__PURE__ */ new Map(),
         users: /* @__PURE__ */ new Map(),
         budgetTokensRemaining: 0,
         budgetTokensTotal: 0,
@@ -573267,8 +574080,10 @@ var init_expose = __esm({
           maxConcurrent: this._sponsorLimits.maxConcurrent,
           blockedRequests: this._sponsorBlockedRequests,
           allowedModels: this._sponsorLimits.allowedModels === "all" ? "all" : [...this._sponsorLimits.allowedModels],
+          mediaLimits: this._sponsorLimits.media ? normalizeSponsorMediaConfig(this._sponsorLimits.media) : void 0,
           peers: serializeSponsorPeers(this._stats),
-          models: serializeSponsorModels(this._stats)
+          models: serializeSponsorModels(this._stats),
+          media: serializeSponsorMedia(this._stats)
         };
       }
       recordServedTokens(tokens, now = Date.now()) {
@@ -573526,7 +574341,8 @@ var init_expose = __esm({
               tokensIn: 0,
               tokensOut: 0,
               activeRequests: 0,
-              models: /* @__PURE__ */ new Map()
+              models: /* @__PURE__ */ new Map(),
+              media: /* @__PURE__ */ new Map()
             };
             this._stats.users.set(userIp, user);
           }
@@ -574030,6 +574846,7 @@ ${this.formatConnectionInfo()}`);
         this.emit("stats", {
           ...this._stats,
           modelUsage: new Map(this._stats.modelUsage),
+          mediaUsage: new Map(this._stats.mediaUsage),
           users: new Map(this._stats.users),
           sponsorUsage: this._stats.sponsorUsage ? { ...this._stats.sponsorUsage } : null
         });
@@ -574095,6 +574912,10 @@ ${this.formatConnectionInfo()}`);
             total: s2.sponsorUsage.maxConcurrent
           })}`);
           lines.push(`  ${c3.cyan("Blocked".padEnd(18))} ${s2.sponsorUsage.blockedRequests}`);
+          const enabledMedia = s2.sponsorUsage.mediaLimits ? SPONSOR_MEDIA_MODALITIES.filter((modality) => s2.sponsorUsage?.mediaLimits?.[modality]?.enabled) : [];
+          if (enabledMedia.length > 0) {
+            lines.push(`  ${c3.cyan("Media".padEnd(18))} ${enabledMedia.join(", ")}`);
+          }
         }
         const visibleModels = Array.from(s2.modelUsage.entries()).filter(([model]) => !INTERNAL_CAPABILITIES.has(model));
         if (visibleModels.length > 0) {
@@ -574112,6 +574933,15 @@ ${this.formatConnectionInfo()}`);
             lines.push(`  ${c3.cyan(model.padEnd(30))} ${count} reqs  ${c3.dim(`in:${fmtTokens(mIn)} out:${fmtTokens(mOut)}`)}`);
           }
         }
+        const mediaUsage = serializeSponsorMedia(s2);
+        if (mediaUsage.length > 0) {
+          lines.push("");
+          lines.push(`  ${c3.bold("Media Jobs")}`);
+          for (const media of mediaUsage.slice(0, 10)) {
+            const mb = media.bytesOut > 0 ? `${(media.bytesOut / (1024 * 1024)).toFixed(1)}MB` : "0MB";
+            lines.push(`  ${c3.cyan(media.key.padEnd(30))} ${media.jobs} jobs  ${c3.dim(`${mb} out ${media.avgLatencyMs}ms avg`)}`);
+          }
+        }
         if (s2.users.size > 0) {
           lines.push("");
           lines.push(`  ${c3.bold("Active Users")} (${s2.users.size})`);
@@ -574180,6 +575010,7 @@ ${this.formatConnectionInfo()}`);
         tokensPerSecond: 0,
         startedAt: Date.now(),
         modelUsage: /* @__PURE__ */ new Map(),
+        mediaUsage: /* @__PURE__ */ new Map(),
         users: /* @__PURE__ */ new Map(),
         budgetTokensRemaining: 0,
         budgetTokensTotal: 0,
@@ -574318,8 +575149,10 @@ ${this.formatConnectionInfo()}`);
           maxConcurrent: this._sponsorLimits.maxConcurrent,
           blockedRequests: this._sponsorBlockedRequests,
           allowedModels: this._sponsorLimits.allowedModels === "all" ? "all" : [...this._sponsorLimits.allowedModels],
+          mediaLimits: this._sponsorLimits.media ? normalizeSponsorMediaConfig(this._sponsorLimits.media) : void 0,
           peers: serializeSponsorPeers(this._stats),
-          models: serializeSponsorModels(this._stats)
+          models: serializeSponsorModels(this._stats),
+          media: serializeSponsorMedia(this._stats)
         };
       }
       recordServedTokens(tokens, now = Date.now()) {
@@ -574344,6 +575177,9 @@ ${this.formatConnectionInfo()}`);
           exposeArgs.daily_tokens_used = String(this._dailyTokensUsed);
           exposeArgs.daily_tokens_reset_at = String(this._dailyTokensResetAt);
           exposeArgs.allowed_models = this._sponsorLimits.allowedModels === "all" ? "all" : this._sponsorLimits.allowedModels.join(",");
+          if (this._sponsorLimits.media) {
+            exposeArgs.media_config = JSON.stringify(normalizeSponsorMediaConfig(this._sponsorLimits.media));
+          }
         }
         return exposeArgs;
       }
@@ -574594,6 +575430,55 @@ ${this.formatConnectionInfo()}`);
                       this.refreshSponsorUsageStats();
                       continue;
                     }
+                    if (record.modality) {
+                      const modality = String(record.modality);
+                      const modelName = String(record.model || "auto");
+                      const mediaKey2 = `${modality}:${modelName}`;
+                      const outputBytes = safeNonNegativeInt(record.outputBytes ?? record.artifactBytes ?? 0);
+                      const durationMs = safeNonNegativeInt(record.durationMs);
+                      let mediaMeter = this._stats.mediaUsage.get(mediaKey2);
+                      if (!mediaMeter) {
+                        mediaMeter = { jobs: 0, bytesOut: 0, failures: 0, lastUsed: 0, totalLatencyMs: 0 };
+                        this._stats.mediaUsage.set(mediaKey2, mediaMeter);
+                      }
+                      mediaMeter.jobs++;
+                      mediaMeter.bytesOut += outputBytes;
+                      mediaMeter.failures += record.success === false ? 1 : 0;
+                      mediaMeter.lastUsed = Date.now();
+                      mediaMeter.totalLatencyMs += durationMs;
+                      this.recordSponsorRequest();
+                      const peerId2 = record.from || record.peerId || "unknown";
+                      const shortPeer2 = peerId2.length > 16 ? peerId2.slice(0, 16) + "..." : peerId2;
+                      let user2 = this._stats.users.get(shortPeer2);
+                      if (!user2) {
+                        user2 = {
+                          ip: shortPeer2,
+                          firstSeen: Date.now(),
+                          lastSeen: Date.now(),
+                          requests: 0,
+                          tokensIn: 0,
+                          tokensOut: 0,
+                          activeRequests: 0,
+                          models: /* @__PURE__ */ new Map(),
+                          media: /* @__PURE__ */ new Map()
+                        };
+                        this._stats.users.set(shortPeer2, user2);
+                      }
+                      user2.requests++;
+                      user2.lastSeen = Date.now();
+                      let userMedia = user2.media.get(mediaKey2);
+                      if (!userMedia) {
+                        userMedia = { jobs: 0, bytesOut: 0, failures: 0, lastUsed: 0, totalLatencyMs: 0 };
+                        user2.media.set(mediaKey2, userMedia);
+                      }
+                      userMedia.jobs++;
+                      userMedia.bytesOut += outputBytes;
+                      userMedia.failures += record.success === false ? 1 : 0;
+                      userMedia.lastUsed = Date.now();
+                      userMedia.totalLatencyMs += durationMs;
+                      this._stats.modelUsage.set(mediaKey2, (this._stats.modelUsage.get(mediaKey2) ?? 0) + 1);
+                      continue;
+                    }
                     let tokIn = 0;
                     let tokOut = 0;
                     if (typeof record.inputTokens === "number" && typeof record.outputTokens === "number") {
@@ -574629,7 +575514,8 @@ ${this.formatConnectionInfo()}`);
                         tokensIn: 0,
                         tokensOut: 0,
                         activeRequests: 0,
-                        models: /* @__PURE__ */ new Map()
+                        models: /* @__PURE__ */ new Map(),
+                        media: /* @__PURE__ */ new Map()
                       };
                       this._stats.users.set(shortPeer, user);
                     }
@@ -574684,6 +575570,7 @@ ${this.formatConnectionInfo()}`);
         this.emit("stats", {
           ...this._stats,
           modelUsage: new Map(this._stats.modelUsage),
+          mediaUsage: new Map(this._stats.mediaUsage),
           users: new Map(this._stats.users),
           sponsorUsage: this._stats.sponsorUsage ? { ...this._stats.sponsorUsage } : null
         });
@@ -574823,7 +575710,7 @@ var init_types = __esm({
 });
 
 // packages/cli/src/tui/p2p/secret-vault.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes21, scryptSync as scryptSync2, createHash as createHash21 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes21, scryptSync as scryptSync2, createHash as createHash22 } from "node:crypto";
 import { readFileSync as readFileSync72, writeFileSync as writeFileSync46, existsSync as existsSync91, mkdirSync as mkdirSync51 } from "node:fs";
 import { dirname as dirname28 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
@@ -575068,7 +575955,7 @@ var init_secret_vault = __esm({
       /** Generate a deterministic fingerprint of vault contents (for sync verification) */
       fingerprint() {
         const names = Array.from(this.secrets.keys()).sort();
-        const hash = createHash21("sha256");
+        const hash = createHash22("sha256");
         for (const name10 of names) {
           hash.update(name10 + ":");
           hash.update(this.secrets.get(name10).value);
@@ -575083,7 +575970,7 @@ var init_secret_vault = __esm({
 // packages/cli/src/tui/p2p/peer-mesh.ts
 import { EventEmitter as EventEmitter9 } from "node:events";
 import { createServer as createServer6 } from "node:http";
-import { randomBytes as randomBytes22, createHash as createHash22, generateKeyPairSync } from "node:crypto";
+import { randomBytes as randomBytes22, createHash as createHash23, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
 var init_peer_mesh = __esm({
   "packages/cli/src/tui/p2p/peer-mesh.ts"() {
@@ -575100,7 +575987,7 @@ var init_peer_mesh = __esm({
         const { publicKey: publicKey2, privateKey } = generateKeyPairSync("ed25519");
         this.publicKey = publicKey2.export({ type: "spki", format: "der" });
         this.privateKey = privateKey.export({ type: "pkcs8", format: "der" });
-        this.peerId = createHash22("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
+        this.peerId = createHash23("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
         this.capabilities = options2.capabilities;
         this.displayName = options2.displayName;
         this._authKey = options2.authKey ?? randomBytes22(24).toString("base64url");
@@ -576438,7 +577325,7 @@ __export(omnius_directory_exports, {
 import { appendFileSync as appendFileSync6, cpSync as cpSync2, existsSync as existsSync94, mkdirSync as mkdirSync53, readFileSync as readFileSync75, writeFileSync as writeFileSync48, readdirSync as readdirSync31, statSync as statSync36, unlinkSync as unlinkSync17, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync4, watch as fsWatch2 } from "node:fs";
 import { join as join110, relative as relative9, basename as basename21, dirname as dirname31, resolve as resolve41 } from "node:path";
 import { homedir as homedir34 } from "node:os";
-import { createHash as createHash23 } from "node:crypto";
+import { createHash as createHash24 } from "node:crypto";
 function isGitRoot(dir) {
   const gitPath = join110(dir, ".git");
   if (!existsSync94(gitPath)) return false;
@@ -576892,7 +577779,7 @@ function buildHandoffPrompt(repoRoot) {
   return lines.join("\n");
 }
 function computeDedupeHash(task, savedAt) {
-  return createHash23("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
+  return createHash24("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
 }
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
@@ -591805,7 +592692,8 @@ function defaultConfig2() {
       maxRequestsPerMinute: 60,
       maxTokensPerDay: 1e5,
       maxConcurrent: 5,
-      allowedModels: "all"
+      allowedModels: "all",
+      media: normalizeSponsorMediaConfig(DEFAULT_SPONSOR_MEDIA_LIMITS)
     },
     cohereEnabled: true,
     status: "inactive",
@@ -591813,6 +592701,10 @@ function defaultConfig2() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function normalizeLoadedSponsorConfig(config) {
+  config.rateLimits.media = normalizeSponsorMediaConfig(config.rateLimits.media);
+  return config;
+}
 function endpointAuthToken(authHeader) {
   const raw = (authHeader || "").trim();
   if (!raw) return void 0;
@@ -592454,6 +593346,99 @@ async function stepTransport(config, rl, availableRows) {
   }
   return false;
 }
+function mediaLimitSummary(modality, media) {
+  const limits = media[modality];
+  if (modality === "image") {
+    return `${limits.maxConcurrent} concurrent, ${limits.jobsPerDay}/day, ${limits.maxWidth}x${limits.maxHeight}, ${limits.maxSteps} steps`;
+  }
+  if (modality === "video") {
+    return `${limits.maxConcurrent} concurrent, ${limits.jobsPerDay}/day, ${limits.maxDurationSec}s, ${limits.maxFrames} frames, ${limits.maxOutputBytes} bytes`;
+  }
+  return `${limits.maxConcurrent} concurrent, ${limits.jobsPerDay}/day, ${limits.maxDurationSec}s, ${limits.maxOutputBytes} bytes`;
+}
+async function stepMedia(config, rl, availableRows) {
+  const media = normalizeSponsorMediaConfig(config.rateLimits.media);
+  config.rateLimits.media = media;
+  const items = [
+    { key: "hdr", label: "Sponsored Media Generation" },
+    { key: "desc", label: "  Remote consumers use /sponsor image|video|sound|music. Setup/prewarm stays provider-only." }
+  ];
+  for (const modality of SPONSOR_MEDIA_MODALITIES) {
+    const limits = media[modality];
+    items.push({
+      key: `toggle:${modality}`,
+      label: `  ${limits.enabled ? "[x]" : "[ ]"} ${modality}`,
+      detail: mediaLimitSummary(modality, media)
+    });
+  }
+  items.push({ key: "sep", label: "" });
+  items.push({ key: "next", label: selectColors.green("  Next Step  →") });
+  const updateItem = (item, modality) => {
+    const limits = media[modality];
+    item.label = `  ${limits.enabled ? "[x]" : "[ ]"} ${modality}`;
+    item.detail = mediaLimitSummary(modality, media);
+  };
+  const result = await tuiSelect({
+    items,
+    title: "Step 5/7 — Media Generation",
+    rl,
+    skipKeys: ["hdr", "desc", "sep"],
+    availableRows,
+    customKeyHint: "  space/Enter toggle  e edit limits",
+    onAction: (item, action) => {
+      if (action !== "space" || !item.key.startsWith("toggle:")) return false;
+      const modality = item.key.slice("toggle:".length);
+      media[modality].enabled = !media[modality].enabled;
+      updateItem(item, modality);
+      return true;
+    },
+    onEnter: (item, helpers) => {
+      if (item.key.startsWith("toggle:")) {
+        const modality = item.key.slice("toggle:".length);
+        media[modality].enabled = !media[modality].enabled;
+        updateItem(item, modality);
+        helpers.render();
+        return true;
+      }
+      return false;
+    },
+    onCustomKey: (item, key, helpers) => {
+      if (key !== "e" && key !== "E" || !item.key.startsWith("toggle:")) return false;
+      const modality = item.key.slice("toggle:".length);
+      const limits = media[modality];
+      helpers.getInput("Max concurrent jobs:", String(limits.maxConcurrent)).then((concurrent) => {
+        const c8 = parseInt(concurrent ?? "", 10);
+        if (Number.isFinite(c8) && c8 > 0) limits.maxConcurrent = c8;
+        helpers.getInput("Jobs/day:", String(limits.jobsPerDay)).then((daily) => {
+          const d2 = parseInt(daily ?? "", 10);
+          if (Number.isFinite(d2) && d2 > 0) limits.jobsPerDay = d2;
+          const durationKey = modality === "image" ? "Max steps:" : "Max duration seconds:";
+          const durationValue = modality === "image" ? limits.maxSteps : limits.maxDurationSec;
+          helpers.getInput(durationKey, String(durationValue ?? "")).then((value2) => {
+            const n2 = parseInt(value2 ?? "", 10);
+            if (Number.isFinite(n2) && n2 > 0) {
+              if (modality === "image") limits.maxSteps = n2;
+              else limits.maxDurationSec = n2;
+            }
+            updateItem(item, modality);
+            helpers.render();
+          });
+        });
+      });
+      return true;
+    },
+    renderRow: (item, focused, _isActive) => {
+      const prefix = focused ? selectColors.blue("❯ ") : "  ";
+      if (item.key === "hdr") return selectColors.bold(item.label);
+      if (item.key === "desc") return selectColors.dim(item.label);
+      if (item.detail) return `${prefix}${item.label}
+     ${selectColors.dim(item.detail)}`;
+      return `${prefix}${item.label}`;
+    }
+  });
+  if (!result.confirmed) return false;
+  return result.key === "next";
+}
 async function stepCohere(config, rl, availableRows) {
   const items = [
     { key: "hdr", label: "COHERE — Distributed Intelligence (Experimental)" },
@@ -592480,7 +593465,7 @@ async function stepCohere(config, rl, availableRows) {
   ];
   const result = await tuiSelect({
     items,
-    title: "Step 5/6 — COHERE Distributed Intelligence",
+    title: "Step 6/7 — COHERE Distributed Intelligence",
     rl,
     skipKeys: ["hdr", "desc1", "desc2", "desc3", "desc4", "desc5", "desc6", "desc7", "desc8", "desc9", "desc10", "desc11", "desc12", "desc13", "desc14", "desc15", "desc16", "sep1", "sep2"],
     availableRows,
@@ -592517,6 +593502,9 @@ async function stepReview(config, rl, availableRows) {
   const transports = [];
   if (config.transport.cloudflared) transports.push("Cloudflared Tunnel");
   if (config.transport.libp2p) transports.push("libp2p P2P");
+  const media = normalizeSponsorMediaConfig(config.rateLimits.media);
+  config.rateLimits.media = media;
+  const mediaEnabled = SPONSOR_MEDIA_MODALITIES.filter((modality) => media[modality].enabled);
   const items = [
     { key: "hdr", label: "Review Sponsorship Configuration" },
     { key: "info_ep", label: `  Endpoints: ${epList}` },
@@ -592524,16 +593512,17 @@ async function stepReview(config, rl, availableRows) {
     { key: "info_link", label: `  Link:      ${config.header.linkEnabled ? `${config.header.linkUrl} [${config.header.linkText || config.header.message}]` : "(none)"}` },
     { key: "info_transport", label: `  Transport: ${transports.join(" + ")}` },
     { key: "info_limits", label: `  Limits:    ${config.rateLimits.maxRequestsPerMinute} req/min, ${config.rateLimits.maxTokensPerDay.toLocaleString()} tokens/day` },
+    { key: "info_media", label: `  Media:     ${mediaEnabled.length > 0 ? mediaEnabled.join(", ") : "disabled"}` },
     { key: "info_cohere", label: `  COHERE:    ${config.cohereEnabled ? "enabled (distributed inference)" : "disabled"}` },
     { key: "sep", label: "" },
-    { key: "go_live", label: selectColors.green("  ✦ Go Live & Sponsor Inference  ") },
+    { key: "go_live", label: selectColors.green("  ✦ Go Live & Sponsor Services  ") },
     { key: "cancel", label: selectColors.dim("  Cancel") }
   ];
   const result = await tuiSelect({
     items,
-    title: "Step 6/6 — Review & Go Live",
+    title: "Step 7/7 — Review & Go Live",
     rl,
-    skipKeys: ["hdr", "sep", "info_ep", "info_msg", "info_link", "info_transport", "info_limits", "info_cohere"],
+    skipKeys: ["hdr", "sep", "info_ep", "info_msg", "info_link", "info_transport", "info_limits", "info_media", "info_cohere"],
     availableRows
   });
   if (!result.confirmed || result.key === "cancel") return false;
@@ -592542,11 +593531,14 @@ async function stepReview(config, rl, availableRows) {
 async function showSponsorDashboard(config, projectDir2, rl, availableRows, sponsorUsage) {
   const isPaused = config.status === "paused";
   const enabledEps = config.endpoints.filter((e2) => e2.enabled);
+  config.rateLimits.media = normalizeSponsorMediaConfig(config.rateLimits.media);
+  const enabledMedia = SPONSOR_MEDIA_MODALITIES.filter((modality) => config.rateLimits.media?.[modality]?.enabled);
   const dailyTokensLimit = sponsorUsage?.dailyTokensLimit || config.rateLimits.maxTokensPerDay;
   const requestsPerMinuteLimit = sponsorUsage?.requestsPerMinuteLimit || config.rateLimits.maxRequestsPerMinute;
   const maxConcurrent = sponsorUsage?.maxConcurrent || config.rateLimits.maxConcurrent;
   const topModels = (sponsorUsage?.models ?? []).slice(0, 5);
   const topPeers = (sponsorUsage?.peers ?? []).slice(0, 5);
+  const topMedia = (sponsorUsage?.media ?? []).slice(0, 5);
   const usageItems = [
     {
       key: "info_usage_totals",
@@ -592602,12 +593594,23 @@ async function showSponsorDashboard(config, projectDir2, rl, availableRows, spon
       });
     }
   }
+  if (topMedia.length > 0) {
+    usageItems.push({ key: "info_usage_media_hdr", label: "  Media" });
+    for (const [idx, media] of topMedia.entries()) {
+      const mb = media.bytesOut > 0 ? `${(media.bytesOut / (1024 * 1024)).toFixed(1)}MB` : "0MB";
+      usageItems.push({
+        key: `info_usage_media_${idx}`,
+        label: `    ${media.key}: ${media.jobs} jobs · ${mb}`
+      });
+    }
+  }
   const items = [
     { key: "hdr", label: "Sponsor Dashboard" },
     { key: "info_status", label: `  Status: ${isPaused ? "● PAUSED" : "● ACTIVE"}` },
     { key: "info_ep", label: `  Endpoints: ${enabledEps.map((e2) => e2.label).join(", ")}` },
     { key: "info_transport", label: `  Transport: ${[config.transport.cloudflared ? "Cloudflared" : "", config.transport.libp2p ? "libp2p" : ""].filter(Boolean).join(" + ")}` },
     { key: "info_limits", label: `  Limits: ${config.rateLimits.maxRequestsPerMinute} req/min, ${config.rateLimits.maxTokensPerDay.toLocaleString()} tokens/day, ${config.rateLimits.maxConcurrent} concurrent` },
+    { key: "info_media", label: `  Media: ${enabledMedia.length > 0 ? enabledMedia.join(", ") : "disabled"}` },
     { key: "info_usage_hdr", label: "  Usage" },
     ...usageItems,
     { key: "sep", label: "" },
@@ -592626,7 +593629,7 @@ async function showSponsorDashboard(config, projectDir2, rl, availableRows, spon
   return result.key || "close";
 }
 async function runSponsorWizard(ctx3) {
-  let config = loadSponsorConfig(ctx3.projectDir) || defaultConfig2();
+  let config = normalizeLoadedSponsorConfig(loadSponsorConfig(ctx3.projectDir) || defaultConfig2());
   renderInfo("Starting sponsor onboarding wizard...\n");
   if (!await stepEndpoints(config, ctx3.ollamaUrl, ctx3.rl, ctx3.availableRows, ctx3.projectDir)) {
     renderInfo("Sponsor wizard cancelled.");
@@ -592644,6 +593647,11 @@ async function runSponsorWizard(ctx3) {
     return null;
   }
   saveSponsorConfig(ctx3.projectDir, config);
+  if (!await stepMedia(config, ctx3.rl, ctx3.availableRows)) {
+    renderInfo("Sponsor wizard cancelled.");
+    return null;
+  }
+  saveSponsorConfig(ctx3.projectDir, config);
   if (!await stepCohere(config, ctx3.rl, ctx3.availableRows)) {
     renderInfo("Sponsor wizard cancelled.");
     return null;
@@ -592685,6 +593693,7 @@ var init_sponsor_wizard = __esm({
     init_tui_select();
     init_render();
     init_usage_bars();
+    init_dist5();
   }
 });
 
@@ -596871,6 +597880,7 @@ __export(commands_exports, {
 });
 import * as nodeOs from "node:os";
 import { execSync as nodeExecSync } from "node:child_process";
+import { createHash as createHash25 } from "node:crypto";
 import {
   existsSync as existsSync107,
   readFileSync as readFileSync86,
@@ -596883,7 +597893,7 @@ import {
   appendFileSync as appendFileSync8,
   writeSync as writeSync2
 } from "node:fs";
-import { relative as relative11, join as join120 } from "node:path";
+import { basename as basename23, dirname as dirname35, relative as relative11, join as join120 } from "node:path";
 async function parseJsonResponse(resp, source) {
   const body = await resp.text();
   const trimmed = body.trim();
@@ -597277,12 +598287,12 @@ async function ensureVoiceDeps(ctx3) {
         renderInfo(res.log.split("\n").slice(-3).join(" ").slice(0, 200));
     }
     if (typeof mod2.getVenvPython === "function") {
-      const { dirname: dirname43 } = await import("node:path");
+      const { dirname: dirname44 } = await import("node:path");
       const { existsSync: existsSync137 } = await import("node:fs");
       const venvPy = mod2.getVenvPython();
       if (existsSync137(venvPy)) {
         process.env.TRANSCRIBE_PYTHON = venvPy;
-        const venvBin = dirname43(venvPy);
+        const venvBin = dirname44(venvPy);
         const sep4 = process.platform === "win32" ? ";" : ":";
         const cur = process.env.PATH || "";
         if (!cur.split(sep4).includes(venvBin)) {
@@ -601238,6 +602248,11 @@ sleep 1
       return "handled";
     }
     case "sponsor": {
+      const mediaCommand = parseSponsorMediaCommand(arg);
+      if (mediaCommand) {
+        await handleSponsorMediaCommand(ctx3, mediaCommand.modality, mediaCommand.rest);
+        return "handled";
+      }
       if (!ctx3.rl) {
         renderWarning("Sponsor wizard requires interactive mode.");
         return "handled";
@@ -601484,6 +602499,21 @@ sleep 1
           if (allModels.length > 0) {
             config.rateLimits.allowedModels = allModels;
           }
+          config.rateLimits.media = normalizeSponsorMediaConfig(config.rateLimits.media);
+          const sponsorServices = [
+            ...allModels.map((model) => ({
+              kind: "llm",
+              capability: `inference:${model.replace(/[^a-zA-Z0-9._-]/g, "_")}`,
+              model,
+              input: ["messages", "prompt"],
+              output: ["text"],
+              limits: {
+                maxRequestsPerMinute: config.rateLimits.maxRequestsPerMinute,
+                maxTokensPerDay: config.rateLimits.maxTokensPerDay
+              }
+            })),
+            ...buildSponsorMediaServices(config.rateLimits.media)
+          ];
           renderInfo(
             `Sponsoring ${primaryProvider.label} endpoint: ${new URL(primaryUrl).host}`
           );
@@ -601742,8 +602772,11 @@ sleep 1
             limits: {
               maxRequestsPerMinute: config.rateLimits.maxRequestsPerMinute,
               maxTokensPerDay: config.rateLimits.maxTokensPerDay,
-              maxConcurrent: config.rateLimits.maxConcurrent
+              maxConcurrent: config.rateLimits.maxConcurrent,
+              media: config.rateLimits.media
             },
+            services: sponsorServices,
+            mediaCapabilities: sponsorServices.filter((service) => service.kind !== "llm"),
             banner: "none",
             message: config.header.message || sponsorName,
             linkUrl: config.header.linkUrl,
@@ -606033,14 +607066,14 @@ async function handleVoiceMenu(ctx3, save2, hasLocal) {
             if (!jsonDrop.confirmed || !jsonDrop.path) {
               continue;
             }
-            const { basename: basename34, join: pathJoin } = await import("node:path");
+            const { basename: basename35, join: pathJoin } = await import("node:path");
             const {
               copyFileSync: copyFileSync5,
               mkdirSync: mkdirSync84,
               existsSync: exists2
             } = await import("node:fs");
             const { homedir: homedir56 } = await import("node:os");
-            const modelName = basename34(onnxDrop.path, ".onnx").replace(
+            const modelName = basename35(onnxDrop.path, ".onnx").replace(
               /[^a-zA-Z0-9_-]/g,
               "-"
             );
@@ -606427,7 +607460,7 @@ async function handleVoiceList(ctx3, focusFilename) {
                 copyFileSync: cpf,
                 mkdirSync: mkd
               } = __require("node:fs");
-              const { basename: basename34, join: pjoin } = __require("node:path");
+              const { basename: basename35, join: pjoin } = __require("node:path");
               if (!fe(src2)) {
                 renderError(`File not found: ${src2}`);
                 helpers.render();
@@ -606440,7 +607473,7 @@ async function handleVoiceList(ctx3, focusFilename) {
                 "clone-refs"
               );
               mkd(refsDir, { recursive: true });
-              const destName = basename34(src2);
+              const destName = basename35(src2);
               const dest = pjoin(refsDir, destName);
               cpf(src2, dest);
               renderInfo(`Imported "${destName}" → ${dest}`);
@@ -606924,6 +607957,340 @@ async function handleEndpoint(arg, ctx3, local = false) {
     );
   }
 }
+function parseSponsorMediaCommand(arg) {
+  const trimmed = arg.trim();
+  if (!trimmed) return null;
+  const firstSpace = trimmed.indexOf(" ");
+  const head = (firstSpace >= 0 ? trimmed.slice(0, firstSpace) : trimmed).toLowerCase();
+  if (head !== "image" && head !== "video" && head !== "sound" && head !== "music") return null;
+  return {
+    modality: head,
+    rest: firstSpace >= 0 ? trimmed.slice(firstSpace + 1).trim() : ""
+  };
+}
+function parseSponsorMediaArgs(rest) {
+  const tokens = shellLikeTokens(rest);
+  const promptParts = [];
+  const options2 = {};
+  let model;
+  let backend;
+  for (let i2 = 0; i2 < tokens.length; i2++) {
+    const token = tokens[i2];
+    if (!token.startsWith("--")) {
+      promptParts.push(token);
+      continue;
+    }
+    const eq = token.indexOf("=");
+    const key = token.slice(2, eq >= 0 ? eq : void 0).replace(/-/g, "_");
+    const rawValue = eq >= 0 ? token.slice(eq + 1) : tokens[i2 + 1];
+    if (eq < 0 && rawValue && !rawValue.startsWith("--")) i2++;
+    const value2 = coerceSponsorMediaOption(rawValue ?? "true");
+    if (key === "model" && typeof value2 === "string") model = value2;
+    else if (key === "backend" && typeof value2 === "string") backend = value2;
+    else options2[key] = value2;
+  }
+  return { prompt: promptParts.join(" ").trim(), options: options2, model, backend };
+}
+function shellLikeTokens(input) {
+  const tokens = [];
+  let current = "";
+  let quote = "";
+  let escaped = false;
+  for (const ch of input) {
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) quote = "";
+      else current += ch;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+function coerceSponsorMediaOption(value2) {
+  const lower = value2.toLowerCase();
+  if (lower === "true" || lower === "yes" || lower === "on") return true;
+  if (lower === "false" || lower === "no" || lower === "off") return false;
+  const n2 = Number(value2);
+  if (Number.isFinite(n2) && value2.trim() !== "") return n2;
+  return value2;
+}
+async function discoverSponsorMediaCandidates(ctx3, modality) {
+  const rawSponsors = [];
+  const projectDir2 = ctx3.repoRoot ?? process.cwd();
+  try {
+    const nexus = new NexusTool(projectDir2);
+    const status = String((await nexus.execute({ action: "status" }))?.output ?? "");
+    if (!/Connected:\s*true/i.test(status) && ctx3.nexusConnect) {
+      await ctx3.nexusConnect();
+    }
+    const discovered = await nexus.execute({ action: "sponsor_discover", timeout_ms: "5000" });
+    const output = String(discovered?.output ?? "");
+    if (output) {
+      const parsed = JSON.parse(output);
+      rawSponsors.push(...Array.isArray(parsed.sponsors) ? parsed.sponsors : []);
+    }
+  } catch {
+  }
+  try {
+    const resp = await fetch("https://omnius.nexus/api/v1/sponsors", { signal: AbortSignal.timeout(5e3) });
+    if (resp.ok) {
+      const data = await parseJsonResponse(resp, "Sponsor directory");
+      rawSponsors.push(...(data.sponsors ?? []).filter((s2) => s2.status === "active"));
+    }
+  } catch {
+  }
+  try {
+    const knownFile = join120(projectDir2, ".omnius", "sponsor", "known-sponsors.json");
+    if (existsSync107(knownFile)) {
+      const saved = JSON.parse(readFileSync86(knownFile, "utf8"));
+      if (Array.isArray(saved)) rawSponsors.push(...saved);
+    }
+  } catch {
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (const raw of rawSponsors) {
+    const peerId = String(raw?.libp2pPeerId || raw?.peerId || "").trim();
+    if (!peerId) continue;
+    const services = normalizeSponsorServices(raw);
+    const mediaServices = services.filter((service) => service.kind === modality);
+    if (mediaServices.length === 0) continue;
+    const sponsor = {
+      name: String(raw?.name || "Unknown Sponsor"),
+      peerId,
+      authKey: String(raw?.authKey || raw?.auth_key || "").trim() || void 0,
+      services
+    };
+    for (const service of mediaServices) {
+      const key = `${peerId}:${service.capability}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      candidates.push({ sponsor, service });
+    }
+  }
+  return candidates;
+}
+function normalizeSponsorServices(raw) {
+  const services = Array.isArray(raw?.services) ? raw.services : Array.isArray(raw?.mediaCapabilities) ? raw.mediaCapabilities : [];
+  return services.map((service) => {
+    const kind = String(service?.kind || "");
+    if (kind !== "llm" && kind !== "image" && kind !== "video" && kind !== "sound" && kind !== "music") return null;
+    const capability = String(service?.capability || "").trim();
+    if (!capability) return null;
+    return {
+      kind,
+      capability,
+      model: String(service?.model || "auto"),
+      backend: service?.backend ? String(service.backend) : void 0,
+      input: Array.isArray(service?.input) ? service.input.map(String) : [],
+      output: Array.isArray(service?.output) ? service.output.map(String) : [],
+      limits: service?.limits && typeof service.limits === "object" ? service.limits : {}
+    };
+  }).filter((service) => Boolean(service));
+}
+async function handleSponsorMediaCommand(ctx3, modality, rest) {
+  const parsedArgs = parseSponsorMediaArgs(rest);
+  if (!parsedArgs.prompt) {
+    renderInfo(`Usage: /sponsor ${modality} "<prompt>" [--model name] [--backend name]`);
+    return;
+  }
+  renderInfo(`Scanning for sponsored ${modality} generation services...`);
+  const candidates = await discoverSponsorMediaCandidates(ctx3, modality);
+  if (candidates.length === 0) {
+    renderWarning(`No sponsored ${modality} generation services found.`);
+    return;
+  }
+  let selected = candidates[0];
+  if (ctx3.rl && candidates.length > 1) {
+    const items = [
+      { key: "hdr", label: `Sponsored ${modality} Services` },
+      ...candidates.map((candidate, index) => ({
+        key: String(index),
+        label: `  ${candidate.sponsor.name}`,
+        detail: `${candidate.service.capability} · model ${candidate.service.model || "auto"}`
+      }))
+    ];
+    const result2 = await tuiSelect({
+      items,
+      title: `Choose Sponsored ${modality}`,
+      rl: ctx3.rl,
+      skipKeys: ["hdr"],
+      availableRows: ctx3.availableContentRows?.()
+    });
+    if (!result2.confirmed) {
+      renderInfo("Cancelled.");
+      return;
+    }
+    selected = candidates[Number(result2.key) || 0] ?? selected;
+  }
+  const projectDir2 = ctx3.repoRoot ?? process.cwd();
+  const streamDir = join120(projectDir2, ".omnius", "sponsor", "streams");
+  mkdirSync59(streamDir, { recursive: true });
+  const streamFile = join120(streamDir, `media-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.jsonl`);
+  writeFileSync54(streamFile, "", "utf8");
+  const request = {
+    modality,
+    prompt: parsedArgs.prompt,
+    ...parsedArgs.model ? { model: parsedArgs.model } : {},
+    ...parsedArgs.backend ? { backend: parsedArgs.backend } : {},
+    options: parsedArgs.options,
+    ...selected.sponsor.authKey ? { auth_key: selected.sponsor.authKey } : {}
+  };
+  renderInfo(`Requesting ${modality} from ${selected.sponsor.name} (${selected.service.capability})...`);
+  const nexus = new NexusTool(projectDir2);
+  const start2 = await nexus.execute({
+    action: "invoke_capability",
+    target_peer: selected.sponsor.peerId,
+    capability: selected.service.capability,
+    input: JSON.stringify(request),
+    stream_file: streamFile
+  });
+  if (!start2.success) {
+    renderError(start2.error || start2.output || "Remote media invocation failed to start.");
+    return;
+  }
+  const result = await collectSponsorMediaStream({
+    streamFile,
+    outputRoot: join120(projectDir2, ".omnius", "remote-media", selected.sponsor.peerId.slice(0, 16)),
+    modality
+  });
+  if (!result.ok) {
+    renderError(result.error);
+    return;
+  }
+  renderInfo(`${modality} generated: ${result.path}`);
+  if (result.metadata?.model) renderInfo(`Model: ${result.metadata.model}`);
+}
+async function collectSponsorMediaStream(args) {
+  mkdirSync59(args.outputRoot, { recursive: true });
+  let offset = 0;
+  let pending2 = "";
+  let done = false;
+  let lastProgress = "";
+  let metadata = null;
+  const artifacts = /* @__PURE__ */ new Map();
+  const deadline = Date.now() + 30 * 60 * 1e3;
+  while (!done && Date.now() < deadline) {
+    await new Promise((resolve56) => setTimeout(resolve56, 250));
+    if (!existsSync107(args.streamFile)) continue;
+    const raw = readFileSync86(args.streamFile, "utf8");
+    if (raw.length <= offset) continue;
+    pending2 += raw.slice(offset);
+    offset = raw.length;
+    const lines = pending2.split("\n");
+    pending2 = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let eventLine;
+      try {
+        eventLine = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (eventLine.type === "done") {
+        done = true;
+        continue;
+      }
+      if (eventLine.type === "error") {
+        return { ok: false, error: String(eventLine.error || "Remote media stream failed") };
+      }
+      if (eventLine.type !== "event") continue;
+      if (eventLine.event === "error") {
+        return { ok: false, error: String(eventLine.data || "Remote media generation failed") };
+      }
+      const payload = parseMaybeJson(eventLine.data);
+      if (eventLine.event === "progress") {
+        const msg = String(payload?.message || payload?.stage || eventLine.data || "");
+        if (msg && msg !== lastProgress) {
+          lastProgress = msg;
+          renderInfo(`${args.modality}: ${msg}`);
+        }
+        continue;
+      }
+      if (eventLine.event === "artifact.begin") {
+        const artifactId2 = String(payload?.artifactId || "artifact");
+        artifacts.set(artifactId2, {
+          filename: String(payload?.filename || `${artifactId2}${defaultExtensionForMime(String(payload?.mime || ""))}`),
+          mime: String(payload?.mime || mediaMimeFromPath(payload?.filename || "", args.modality)),
+          chunks: [],
+          sizeBytes: typeof payload?.sizeBytes === "number" ? payload.sizeBytes : void 0,
+          sha256: typeof payload?.sha256 === "string" ? payload.sha256 : void 0
+        });
+        continue;
+      }
+      if (eventLine.event === "artifact.chunk") {
+        const artifactId2 = String(payload?.artifactId || "artifact");
+        let artifact2 = artifacts.get(artifactId2);
+        if (!artifact2) {
+          artifact2 = { filename: `${artifactId2}.bin`, mime: "application/octet-stream", chunks: [] };
+          artifacts.set(artifactId2, artifact2);
+        }
+        if (typeof payload?.dataBase64 === "string") {
+          artifact2.chunks.push(Buffer.from(payload.dataBase64, "base64"));
+        }
+        continue;
+      }
+      if (eventLine.event === "artifact.end") {
+        const artifactId2 = String(payload?.artifactId || "artifact");
+        const artifact2 = artifacts.get(artifactId2);
+        if (artifact2) {
+          artifact2.sha256 = String(payload?.sha256 || artifact2.sha256 || "");
+          artifact2.sizeBytes = typeof payload?.sizeBytes === "number" ? payload.sizeBytes : artifact2.sizeBytes;
+        }
+        continue;
+      }
+      if (eventLine.event === "result") {
+        metadata = payload;
+      }
+    }
+  }
+  if (!done) return { ok: false, error: "Remote media stream timed out." };
+  const first2 = artifacts.entries().next();
+  if (first2.done) return { ok: false, error: "Remote media completed without an artifact." };
+  const [artifactId, artifact] = first2.value;
+  const bytes = Buffer.concat(artifact.chunks);
+  if (artifact.sizeBytes !== void 0 && bytes.length !== artifact.sizeBytes) {
+    return { ok: false, error: `Artifact size mismatch for ${artifactId}: ${bytes.length}/${artifact.sizeBytes}` };
+  }
+  if (artifact.sha256) {
+    const sha = createHash25("sha256").update(bytes).digest("hex");
+    if (sha !== artifact.sha256) return { ok: false, error: `Artifact hash mismatch for ${artifactId}` };
+  }
+  const safeName3 = basename23(artifact.filename).replace(/[^\w.-]/g, "_") || `artifact${defaultExtensionForMime(artifact.mime)}`;
+  const outputPath3 = join120(args.outputRoot, safeName3);
+  mkdirSync59(dirname35(outputPath3), { recursive: true });
+  writeFileSync54(outputPath3, bytes);
+  return { ok: true, path: outputPath3, metadata };
+}
+function parseMaybeJson(value2) {
+  if (typeof value2 !== "string") return value2;
+  try {
+    return JSON.parse(value2);
+  } catch {
+    return value2;
+  }
+}
 async function handleSponsoredEndpoint(ctx3, local) {
   renderInfo("Scanning for sponsored inference endpoints...");
   const sponsors = [];
@@ -607029,6 +608396,8 @@ async function handleSponsoredEndpoint(ctx3, local) {
               peerId: ns.peerId || void 0,
               authKey: ns.authKey || "",
               models: Array.isArray(ns.models) ? ns.models : (ns.models || "").split(",").filter(Boolean),
+              services: normalizeSponsorServices(ns),
+              mediaCapabilities: normalizeSponsorServices(ns).filter((service) => service.kind !== "llm"),
               limits: {
                 rpm: ns.limits?.maxRequestsPerMinute || 60,
                 tpd: ns.limits?.maxTokensPerDay || 1e5
@@ -607093,6 +608462,8 @@ async function handleSponsoredEndpoint(ctx3, local) {
           peerId: ks.peerId || void 0,
           authKey: ks.authKey || "",
           models: Array.isArray(ks.models) ? ks.models : [],
+          services: normalizeSponsorServices(ks),
+          mediaCapabilities: normalizeSponsorServices(ks).filter((service) => service.kind !== "llm"),
           limits: {
             rpm: ks.limits?.maxRequestsPerMinute || 60,
             tpd: ks.limits?.maxTokensPerDay || 1e5
@@ -607385,14 +608756,14 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local) {
     if (models.length > 0) {
       try {
         const { writeFileSync: writeFileSync76, mkdirSync: mkdirSync84 } = await import("node:fs");
-        const { join: join154, dirname: dirname43 } = await import("node:path");
+        const { join: join154, dirname: dirname44 } = await import("node:path");
         const cachePath = join154(
           ctx3.repoRoot || process.cwd(),
           ".omnius",
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync84(dirname43(cachePath), { recursive: true });
+        mkdirSync84(dirname44(cachePath), { recursive: true });
         writeFileSync76(
           cachePath,
           JSON.stringify(
@@ -608367,10 +609738,10 @@ async function handleUpdate(subcommand, ctx3) {
   try {
     const { createRequire: createRequire10 } = await import("node:module");
     const { fileURLToPath: fileURLToPath21 } = await import("node:url");
-    const { dirname: dirname43, join: join154 } = await import("node:path");
+    const { dirname: dirname44, join: join154 } = await import("node:path");
     const { existsSync: existsSync137 } = await import("node:fs");
     const req2 = createRequire10(import.meta.url);
-    const thisDir = dirname43(fileURLToPath21(import.meta.url));
+    const thisDir = dirname44(fileURLToPath21(import.meta.url));
     const candidates = [
       join154(thisDir, "..", "package.json"),
       join154(thisDir, "..", "..", "package.json"),
@@ -610214,7 +611585,7 @@ var init_commands = __esm({
 
 // packages/cli/src/tui/project-context.ts
 import { existsSync as existsSync108, readFileSync as readFileSync87, readdirSync as readdirSync36 } from "node:fs";
-import { join as join121, basename as basename23 } from "node:path";
+import { join as join121, basename as basename24 } from "node:path";
 import { execSync as execSync54 } from "node:child_process";
 import { homedir as homedir42 } from "node:os";
 function getModelTier(modelName) {
@@ -610295,7 +611666,7 @@ function loadMemoryContext(repoRoot) {
         try {
           const raw = readFileSync87(join121(dir, file), "utf-8");
           const entries = JSON.parse(raw);
-          const topic = basename23(file, ".json");
+          const topic = basename24(file, ".json");
           for (const [k, v] of Object.entries(entries)) {
             if (!v?.value) continue;
             all2.push({ topic, key: k, value: String(v.value), scope, ts: v.timestamp ?? "" });
@@ -610559,7 +611930,7 @@ __export(visual_identity_association_exports, {
   formatVisualIdentityAssociationContext: () => formatVisualIdentityAssociationContext,
   stageVisualIdentityAssertion: () => stageVisualIdentityAssertion
 });
-import { basename as basename24 } from "node:path";
+import { basename as basename25 } from "node:path";
 function normalizePersonName(name10) {
   return name10.trim().toLowerCase().replace(/\s+/g, " ");
 }
@@ -610881,7 +612252,7 @@ async function associateVisualIdentityFromImage(options2) {
             relation: "same_person_candidate",
             confidence: match.confidence,
             assertedBy: { id: "visual_memory", displayName: "visual_memory", isBot: true },
-            note: `Prior enrolled visual-memory face match for ${basename24(options2.imagePath)}`
+            note: `Prior enrolled visual-memory face match for ${basename25(options2.imagePath)}`
           }]
         });
         if (result2.episodeId) committedEpisodeIds.push(result2.episodeId);
@@ -610926,7 +612297,7 @@ async function associateVisualIdentityFromImage(options2) {
             relation: "depicts",
             confidence: item.confidence,
             assertedBy: item.sender || options2.sender,
-            note: item.note || `Applied explicit pending identity assertion to ${basename24(options2.imagePath)}`
+            note: item.note || `Applied explicit pending identity assertion to ${basename25(options2.imagePath)}`
           }]
         });
         if (result2.episodeId) committedEpisodeIds.push(result2.episodeId);
@@ -610984,7 +612355,7 @@ var init_visual_identity_association = __esm({
 
 // packages/cli/src/tui/identity-memory-tool.ts
 import { existsSync as existsSync109 } from "node:fs";
-import { basename as basename25, extname as extname14, resolve as resolve45 } from "node:path";
+import { basename as basename26, extname as extname14, resolve as resolve45 } from "node:path";
 function personKey2(name10) {
   return `person:${name10.trim().toLowerCase().replace(/\s+/g, " ")}`;
 }
@@ -611053,7 +612424,7 @@ async function resolveMediaFromArgs(args, opts) {
     path: path12,
     media,
     modality: inferModality(media),
-    label: basename25(path12)
+    label: basename26(path12)
   };
 }
 function edgeDirection(edge, nodeId, otherText) {
@@ -611211,7 +612582,7 @@ var init_identity_memory_tool = __esm({
         } else if (shouldEnrollFace) {
           faceLine = "face enrollment: skipped because no resolved image path was available";
         }
-        const mediaLine = resolvedMedia ? `media: ${resolvedMedia.label || basename25(resolvedMedia.path)} (${resolvedMedia.path})` : "media: none; stored as scoped textual identity evidence only";
+        const mediaLine = resolvedMedia ? `media: ${resolvedMedia.label || basename26(resolvedMedia.path)} (${resolvedMedia.path})` : "media: none; stored as scoped textual identity evidence only";
         const output = [
           `Stored identity evidence for ${name10}.`,
           `relation: ${relation}`,
@@ -612152,7 +613523,7 @@ var init_banner = __esm({
 
 // packages/cli/src/tui/carousel-descriptors.ts
 import { existsSync as existsSync111, readFileSync as readFileSync89, writeFileSync as writeFileSync56, mkdirSync as mkdirSync62, readdirSync as readdirSync37 } from "node:fs";
-import { join as join124, basename as basename26 } from "node:path";
+import { join as join124, basename as basename27 } from "node:path";
 function loadToolProfile(repoRoot) {
   const filePath = join124(repoRoot, OMNIUS_DIR, "context", TOOL_PROFILE_FILE);
   try {
@@ -612248,7 +613619,7 @@ function generateDescriptors(repoRoot) {
   extractFromSessions(repoRoot, tags);
   extractFromMemory(repoRoot, tags);
   extractFromToolProfile(profile, tags);
-  const repoName2 = basename26(repoRoot);
+  const repoName2 = basename27(repoRoot);
   if (repoName2 && !tags.includes(repoName2)) {
     tags.push(repoName2);
   }
@@ -613428,7 +614799,7 @@ var init_edit_history = __esm({
 
 // packages/cli/src/tui/promptLoader.ts
 import { readFileSync as readFileSync90, existsSync as existsSync112 } from "node:fs";
-import { join as join126, dirname as dirname35 } from "node:path";
+import { join as join126, dirname as dirname36 } from "node:path";
 import { fileURLToPath as fileURLToPath16 } from "node:url";
 function loadPrompt3(promptPath, vars) {
   let content = cache7.get(promptPath);
@@ -613448,7 +614819,7 @@ var init_promptLoader3 = __esm({
   "packages/cli/src/tui/promptLoader.ts"() {
     "use strict";
     __filename5 = fileURLToPath16(import.meta.url);
-    __dirname6 = dirname35(__filename5);
+    __dirname6 = dirname36(__filename5);
     devPath2 = join126(__dirname6, "..", "..", "prompts");
     publishedPath2 = join126(__dirname6, "..", "prompts");
     PROMPTS_DIR3 = existsSync112(devPath2) ? devPath2 : publishedPath2;
@@ -613458,7 +614829,7 @@ var init_promptLoader3 = __esm({
 
 // packages/cli/src/tui/dream-engine.ts
 import { mkdirSync as mkdirSync64, writeFileSync as writeFileSync57, readFileSync as readFileSync91, existsSync as existsSync113, readdirSync as readdirSync38 } from "node:fs";
-import { join as join127, basename as basename27 } from "node:path";
+import { join as join127, basename as basename28 } from "node:path";
 import { execSync as execSync55 } from "node:child_process";
 function setDreamWriteContent(fn) {
   _dreamWriteContent = fn;
@@ -613671,7 +615042,7 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const content = String(args["content"] ?? "");
         if (!rawPath) return { success: false, output: "", error: "path is required", durationMs: Date.now() - start2 };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/autoresearch") ? join127(this.autoresearchDir, basename27(rawPath)) : join127(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/autoresearch") ? join127(this.autoresearchDir, basename28(rawPath)) : join127(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: writes are confined to .omnius/autoresearch/", durationMs: Date.now() - start2 };
         }
@@ -613706,7 +615077,7 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/autoresearch") ? join127(this.autoresearchDir, basename27(rawPath)) : join127(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/autoresearch") ? join127(this.autoresearchDir, basename28(rawPath)) : join127(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: edits are confined to .omnius/autoresearch/", durationMs: Date.now() - start2 };
         }
@@ -613759,7 +615130,7 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const content = String(args["content"] ?? "");
         if (!rawPath) return { success: false, output: "", error: "path is required", durationMs: Date.now() - start2 };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/dreams") ? join127(this.dreamsDir, basename27(rawPath)) : join127(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/dreams") ? join127(this.dreamsDir, basename28(rawPath)) : join127(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: writes are confined to .omnius/dreams/", durationMs: Date.now() - start2 };
         }
@@ -613794,7 +615165,7 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/dreams") ? join127(this.dreamsDir, basename27(rawPath)) : join127(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/dreams") ? join127(this.dreamsDir, basename28(rawPath)) : join127(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: edits are confined to .omnius/dreams/", durationMs: Date.now() - start2 };
         }
@@ -615395,7 +616766,7 @@ var init_bless_engine = __esm({
 
 // packages/cli/src/tui/dmn-engine.ts
 import { existsSync as existsSync114, readFileSync as readFileSync92, writeFileSync as writeFileSync58, mkdirSync as mkdirSync65, readdirSync as readdirSync39, unlinkSync as unlinkSync21 } from "node:fs";
-import { join as join128, basename as basename28 } from "node:path";
+import { join as join128, basename as basename29 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c8) => {
     const rate = c8.attempts > 0 ? Math.round(c8.successes / c8.attempts * 100) : 0;
@@ -616146,7 +617517,7 @@ OUTPUT: Call task_complete with JSON:
           try {
             const files = readdirSync39(dir).filter((f2) => f2.endsWith(".json"));
             for (const f2 of files) {
-              const topic = basename28(f2, ".json");
+              const topic = basename29(f2, ".json");
               if (!topics.includes(topic)) topics.push(topic);
             }
           } catch {
@@ -616200,7 +617571,7 @@ OUTPUT: Call task_complete with JSON:
 
 // packages/cli/src/tui/snr-engine.ts
 import { existsSync as existsSync115, readdirSync as readdirSync40, readFileSync as readFileSync93 } from "node:fs";
-import { join as join129, basename as basename29 } from "node:path";
+import { join as join129, basename as basename30 } from "node:path";
 function computeDPrime(signalScores, noiseScores) {
   if (signalScores.length === 0 || noiseScores.length === 0) return 0;
   const mean = (arr) => arr.reduce((s2, v) => s2 + v, 0) / arr.length;
@@ -616494,7 +617865,7 @@ Call task_complete with the JSON array when done.`,
           try {
             const files = readdirSync40(dir).filter((f2) => f2.endsWith(".json"));
             for (const f2 of files) {
-              const topic = basename29(f2, ".json");
+              const topic = basename30(f2, ".json");
               if (topics.length > 0 && !topics.includes(topic)) continue;
               try {
                 const data = JSON.parse(readFileSync93(join129(dir, f2), "utf-8"));
@@ -617977,8 +619348,8 @@ import {
 } from "node:fs";
 import { mkdir as mkdir19 } from "node:fs/promises";
 import {
-  basename as basename30,
-  dirname as dirname36,
+  basename as basename31,
+  dirname as dirname37,
   extname as extname15,
   isAbsolute as isAbsolute7,
   join as join130,
@@ -618142,7 +619513,7 @@ function scopedTool(base3, root, mode) {
         if (mode === "edit" && !existsSync116(guarded.path.abs)) {
           const materialized = materializeTelegramCreativeArtifactForSend(rootAbs, guarded.path.rel);
           if (!materialized.ok) return denied(materialized.error);
-          mkdirSync66(dirname36(guarded.path.abs), { recursive: true });
+          mkdirSync66(dirname37(guarded.path.abs), { recursive: true });
           writeFileSync59(guarded.path.abs, readFileSync94(materialized.path));
           materialized.cleanup?.();
           restoredEditPath = guarded.path.abs;
@@ -618211,7 +619582,7 @@ function guardPath(root, rawPath) {
       error: `Path escapes the public creative workspace. Use a relative path under ${rootAbs}.`
     };
   }
-  if (basename30(abs) === MANIFEST_FILE) {
+  if (basename31(abs) === MANIFEST_FILE) {
     return { ok: false, error: "The creative workspace manifest is internal and cannot be edited." };
   }
   return { ok: true, path: { abs, rel } };
@@ -618303,7 +619674,7 @@ function rememberCreated(root, absPath) {
     manifest.objects[rel] = {
       logicalRel: rel,
       storedRel,
-      originalName: basename30(guarded.path.abs),
+      originalName: basename31(guarded.path.abs),
       prefixBytes: prefix.length,
       encrypted: true,
       key: key.toString("base64"),
@@ -618354,7 +619725,7 @@ function materializeTelegramCreativeArtifactForSend(root, rawPath) {
     }
     const stageDir = join130(rootAbs, SEND_DIR, `${Date.now()}-${randomBytes23(8).toString("hex")}`);
     mkdirSync66(stageDir, { recursive: true });
-    const staged = join130(stageDir, object.originalName || basename30(rel));
+    const staged = join130(stageDir, object.originalName || basename31(rel));
     writeFileSync59(staged, payload);
     return {
       ok: true,
@@ -618522,7 +619893,7 @@ var init_telegram_creative_tools = __esm({
         }
         let result;
         try {
-          await mkdir19(dirname36(guarded.path.abs), { recursive: true });
+          await mkdir19(dirname37(guarded.path.abs), { recursive: true });
           const tts = new TtsGenerateTool();
           result = await tts.execute({
             text,
@@ -619024,7 +620395,7 @@ var init_soul_observations = __esm({
 // packages/cli/src/tui/telegram-channel-dmn.ts
 import { existsSync as existsSync117, mkdirSync as mkdirSync67, readdirSync as readdirSync41, readFileSync as readFileSync95, writeFileSync as writeFileSync60 } from "node:fs";
 import { join as join131 } from "node:path";
-import { createHash as createHash24 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 function safeFilePart(value2) {
   return value2.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 80) || "telegram";
 }
@@ -619032,7 +620403,7 @@ function daydreamRoot(repoRoot) {
   return join131(repoRoot, ".omnius", "telegram-daydreams");
 }
 function sessionDir(repoRoot, sessionKey) {
-  const hash = createHash24("sha1").update(sessionKey).digest("hex").slice(0, 20);
+  const hash = createHash26("sha1").update(sessionKey).digest("hex").slice(0, 20);
   return join131(daydreamRoot(repoRoot), safeFilePart(hash));
 }
 function compactLine2(value2, max = 220) {
@@ -619117,7 +620488,7 @@ function buildReplyOpportunities(input, openQuestions) {
   return opportunities;
 }
 function daydreamOpportunityId(input, trigger) {
-  return createHash24("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
+  return createHash26("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
 }
 function clamp019(value2) {
   if (!Number.isFinite(value2)) return 0;
@@ -619437,7 +620808,7 @@ function buildTelegramChannelDaydream(input, corpus, extraction, extractionCommi
   const seed = `${input.sessionKey}:${input.generatedAtMs}:${input.history.length}`;
   return {
     version: 3,
-    id: createHash24("sha1").update(seed).digest("hex").slice(0, 16),
+    id: createHash26("sha1").update(seed).digest("hex").slice(0, 16),
     sessionKey: input.sessionKey,
     chatId: input.chatId,
     chatTitle: input.chatTitle,
@@ -619650,12 +621021,12 @@ var init_telegram_channel_dmn = __esm({
 });
 
 // packages/cli/src/tui/telegram-reflection-corpus.ts
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash27 } from "node:crypto";
 function telegramReflectionMemoryDbPaths(repoRoot) {
   return omniusMemoryDbPaths(repoRoot);
 }
 function stableHash2(value2, length4 = 16) {
-  return createHash25("sha1").update(value2).digest("hex").slice(0, length4);
+  return createHash27("sha1").update(value2).digest("hex").slice(0, length4);
 }
 function clean3(value2) {
   return String(value2 ?? "").replace(/\s+/g, " ").trim();
@@ -620385,7 +621756,7 @@ var init_telegram_reflection_extraction = __esm({
 });
 
 // packages/cli/src/tui/telegram-social-state-types.ts
-import { createHash as createHash26 } from "node:crypto";
+import { createHash as createHash28 } from "node:crypto";
 function telegramSocialActorKey(actor) {
   if (!actor) return "unknown";
   if (typeof actor.userId === "number") return `user:${actor.userId}`;
@@ -620409,7 +621780,7 @@ function appendUnique(items, value2, max) {
   return next.slice(-max);
 }
 function hashTelegramSocialId(parts) {
-  return createHash26("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
+  return createHash28("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
 }
 function cleanUsername(value2) {
   if (typeof value2 !== "string") return void 0;
@@ -621187,10 +622558,10 @@ var init_vision_ingress = __esm({
 
 // packages/cli/src/tui/telegram-bridge.ts
 import { mkdirSync as mkdirSync68, existsSync as existsSync119, unlinkSync as unlinkSync24, readdirSync as readdirSync42, statSync as statSync43, statfsSync as statfsSync5, readFileSync as readFileSync97, writeFileSync as writeFileSync62, appendFileSync as appendFileSync10 } from "node:fs";
-import { join as join133, resolve as resolve47, basename as basename31, relative as relative13, isAbsolute as isAbsolute8, extname as extname16 } from "node:path";
+import { join as join133, resolve as resolve47, basename as basename32, relative as relative13, isAbsolute as isAbsolute8, extname as extname16 } from "node:path";
 import { homedir as homedir43 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
-import { createHash as createHash27, randomBytes as randomBytes24, randomInt } from "node:crypto";
+import { createHash as createHash29, randomBytes as randomBytes24, randomInt } from "node:crypto";
 function cleanTelegramDecisionNote(value2, maxLength = 260) {
   if (typeof value2 !== "string") return void 0;
   const clean5 = stripTelegramHiddenThinking(value2).replace(/\s+/g, " ").trim();
@@ -622129,7 +623500,7 @@ function buildTelegramRuntimeContext(now = /* @__PURE__ */ new Date(), repoRoot)
   ].filter(Boolean).join("\n");
 }
 function telegramSessionIdFromKey(sessionKey) {
-  return `telegram-${createHash27("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
+  return `telegram-${createHash29("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
 }
 function normalizeTelegramSubAgentLimit(value2) {
   const parsed = typeof value2 === "number" ? value2 : typeof value2 === "string" && value2.trim() ? Number(value2.trim()) : TELEGRAM_SUB_AGENT_DEFAULT_LIMIT;
@@ -623744,7 +625115,7 @@ External acquisition contract:
         return !!this.adminAuthChallenge && this.adminAuthChallenge.expiresAtMs > Date.now();
       }
       hashAdminAuthCode(code8) {
-        return createHash27("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
+        return createHash29("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
       }
       viewIdForMessage(msg) {
         return `telegram-${this.sessionKeyForMessage(msg).replace(/[^A-Za-z0-9_-]/g, "-")}`;
@@ -624667,11 +626038,11 @@ ${mediaContext}` : ""
         return payload;
       }
       telegramConversationPath(sessionKey) {
-        const safe = createHash27("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash29("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join133(this.telegramConversationDir, `${safe}.json`);
       }
       telegramConversationLedgerPath(sessionKey) {
-        const safe = createHash27("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash29("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join133(this.telegramConversationDir, `${safe}.events.jsonl`);
       }
       telegramDb() {
@@ -624899,7 +626270,7 @@ ${mediaContext}` : ""
           users,
           relationships: Array.isArray(raw.relationships) ? raw.relationships.slice(0, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT).map((fact) => this.normalizeTelegramAssociativeFact(fact)) : [],
           actions: Array.isArray(raw.actions) ? raw.actions.slice(-TELEGRAM_ASSOCIATIVE_ACTION_LIMIT).map((action) => ({
-            id: String(action.id || createHash27("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)),
+            id: String(action.id || createHash29("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)),
             ts: typeof action.ts === "number" ? action.ts : Date.now(),
             role: action.role === "assistant" ? "assistant" : "user",
             speaker: String(action.speaker || "unknown"),
@@ -624916,7 +626287,7 @@ ${mediaContext}` : ""
         const text = String(raw.text || "").trim();
         const now = Date.now();
         return {
-          id: String(raw.id || createHash27("sha1").update(text || String(now)).digest("hex").slice(0, 12)),
+          id: String(raw.id || createHash29("sha1").update(text || String(now)).digest("hex").slice(0, 12)),
           text,
           tags: Array.isArray(raw.tags) ? raw.tags.map(String).slice(0, 16) : [],
           speakers: Array.isArray(raw.speakers) ? raw.speakers.map(String).slice(0, 16) : [],
@@ -625118,7 +626489,7 @@ ${mediaContext}` : ""
       }
       telegramHistoryBackfillMessageId(sessionKey, entry, index) {
         if (typeof entry.messageId === "number" && Number.isFinite(entry.messageId)) return entry.messageId;
-        const digest3 = createHash27("sha1").update(`${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`).digest("hex").slice(0, 8);
+        const digest3 = createHash29("sha1").update(`${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`).digest("hex").slice(0, 8);
         return -Number.parseInt(digest3, 16);
       }
       backfillTelegramLoadedHistory(sessionKey, history) {
@@ -625889,7 +627260,7 @@ ${mediaContext}` : ""
         }
         const matchingEntry = mediaEntries.find((entry) => {
           if (resolve47(entry.localPath) === resolve47(raw)) return true;
-          if (basename31(entry.localPath) === raw) return true;
+          if (basename32(entry.localPath) === raw) return true;
           if (entry.fileUniqueId === raw || entry.fileId === raw) return true;
           if (entry.messageId && String(entry.messageId) === raw) return true;
           if (entry.messageId && `message_id:${entry.messageId}` === raw.toLowerCase()) return true;
@@ -625926,7 +627297,7 @@ ${mediaContext}` : ""
           }
           return entries.find((entry2) => {
             if (resolve47(entry2.localPath) === resolve47(ref)) return true;
-            if (basename31(entry2.localPath) === ref) return true;
+            if (basename32(entry2.localPath) === ref) return true;
             if (entry2.fileUniqueId === ref || entry2.fileId === ref) return true;
             if (entry2.messageId && String(entry2.messageId) === ref) return true;
             return false;
@@ -625954,7 +627325,7 @@ ${mediaContext}` : ""
             caption: entry.caption
           },
           modality,
-          label: `Telegram message_id ${entry.messageId || "unknown"} ${basename31(entry.localPath)}`,
+          label: `Telegram message_id ${entry.messageId || "unknown"} ${basename32(entry.localPath)}`,
           extractedContent: entry.extractedContent
         };
       }
@@ -626011,7 +627382,7 @@ ${mediaContext}` : ""
         const now = entry.ts ?? Date.now();
         memory.updatedAt = now;
         const speaker = telegramHistorySpeaker(entry);
-        const actionId = createHash27("sha1").update(`${sessionKey}:${entry.role}:${entry.messageId ?? ""}:${now}:${entry.text}`).digest("hex").slice(0, 16);
+        const actionId = createHash29("sha1").update(`${sessionKey}:${entry.role}:${entry.messageId ?? ""}:${now}:${entry.text}`).digest("hex").slice(0, 16);
         if (!memory.actions.some((action) => action.id === actionId)) {
           memory.actions.push({
             id: actionId,
@@ -626133,7 +627504,7 @@ ${mediaContext}` : ""
         let fact = facts.find((item) => item.text.toLowerCase() === key);
         if (!fact) {
           fact = {
-            id: createHash27("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
+            id: createHash29("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
             text: clean5,
             tags: telegramMemoryTags(clean5, entry.mediaSummary),
             speakers: [],
@@ -626188,7 +627559,7 @@ ${mediaContext}` : ""
           const titleTags = tags.slice(0, 4);
           const title = titleTags.length > 0 ? `${speaker} / ${titleTags.join(" ")}` : `${speaker} / conversation`;
           const card = {
-            id: createHash27("sha1").update(`${sessionKey}:${now}:${speaker}:${text}`).digest("hex").slice(0, 12),
+            id: createHash29("sha1").update(`${sessionKey}:${now}:${speaker}:${text}`).digest("hex").slice(0, 12),
             title,
             notes: [],
             tags: [],
@@ -626905,8 +628276,8 @@ ${cardLines.join("\n")}`);
             const caption = entry.caption ? ` caption=${telegramContextJsonString(entry.caption, 120)}` : "";
             const extracted = entry.extractedContent ? `
     extracted=${telegramContextJsonString(entry.extractedContent.replace(/\s+/g, " "), 220)}` : "";
-            const alias = entry.messageId ? `message_id:${entry.messageId}` : basename31(entry.localPath);
-            return `- ${alias}${replyMark}: ${kind}; file ${basename31(entry.localPath)}${caption}${extracted}`;
+            const alias = entry.messageId ? `message_id:${entry.messageId}` : basename32(entry.localPath);
+            return `- ${alias}${replyMark}: ${kind}; file ${basename32(entry.localPath)}${caption}${extracted}`;
           });
           sections.push([
             "### Recent Chat Media",
@@ -628330,7 +629701,7 @@ ${list}` : "No shared group target is currently known for this sender. Ask in th
       }
       telegramRunnerStateDir(sessionKey) {
         if (!this.repoRoot) return void 0;
-        const safe = createHash27("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash29("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join133(this.repoRoot, ".omnius", "telegram-runner-state", safe);
       }
       buildTelegramAdminOverviewContext(currentSessionKey) {
@@ -631781,12 +633152,12 @@ Scoped workspace: ${scopedRoot}`,
               return { success: true, output: `No recent ${kind} media is available in this Telegram chat scope.`, durationMs: performance.now() - start2 };
             }
             const lines = entries.map((entry, index) => {
-              const pathAlias = entry.messageId ? `message_id:${entry.messageId}` : basename31(entry.localPath);
+              const pathAlias = entry.messageId ? `message_id:${entry.messageId}` : basename32(entry.localPath);
               const parts = [
                 `${index + 1}. message_id ${entry.messageId || "unknown"}`,
                 currentMsg?.replyToMessageId === entry.messageId ? "replied-to" : "",
                 telegramCachedMediaIsImage(entry) ? "image" : telegramCachedMediaIsPdf(entry) ? "pdf" : telegramCachedMediaIsAudio(entry) ? "audio" : telegramCachedMediaIsVideo(entry) ? "video" : entry.mediaType,
-                `file=${basename31(entry.localPath)}`,
+                `file=${basename32(entry.localPath)}`,
                 `path_alias=${pathAlias}`,
                 entry.caption ? `caption=${telegramContextJsonString(entry.caption, 140)}` : ""
               ].filter(Boolean);
@@ -631913,8 +633284,8 @@ Scoped workspace: ${scopedRoot}`,
             if (bridge.telegramFileSendAlreadyDeliveredForMessage(currentMsg, sendFingerprint)) {
               return {
                 success: true,
-                output: `Telegram file already sent in this turn: ${basename31(file.path)} as ${kind} to ${String(target.chatId)}`,
-                llmContent: `Already sent ${basename31(file.path)} to Telegram as ${kind}; do not send it again.`,
+                output: `Telegram file already sent in this turn: ${basename32(file.path)} as ${kind} to ${String(target.chatId)}`,
+                llmContent: `Already sent ${basename32(file.path)} to Telegram as ${kind}; do not send it again.`,
                 durationMs: performance.now() - start2,
                 mutated: false,
                 mutatedFiles: []
@@ -631931,8 +633302,8 @@ Scoped workspace: ${scopedRoot}`,
               bridge.rememberTelegramDeliveredArtifactForMessage(currentMsg, ledgerPath);
               return {
                 success: true,
-                output: `Sent Telegram file: ${basename31(file.path)} as ${kind} to ${String(target.chatId)}${messageId ? ` (message_id ${messageId})` : ""}`,
-                llmContent: `Sent ${basename31(file.path)} to Telegram as ${kind}.`,
+                output: `Sent Telegram file: ${basename32(file.path)} as ${kind} to ${String(target.chatId)}${messageId ? ` (message_id ${messageId})` : ""}`,
+                llmContent: `Sent ${basename32(file.path)} to Telegram as ${kind}.`,
                 durationMs: performance.now() - start2,
                 mutated: false,
                 mutatedFiles: []
@@ -632417,7 +633788,7 @@ ${text}`.trim());
         if (!existsSync119(media.value)) throw new Error(`File does not exist: ${media.value}`);
         const buffer2 = readFileSync97(media.value);
         const boundary = `----omnius-media-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        const filename = basename31(media.value);
+        const filename = basename32(media.value);
         const contentType = mimeForPath(media.value, media.kind);
         const parts = [];
         const addField = (name10, value2) => {
@@ -632657,7 +634028,7 @@ Content-Type: ${contentType}\r
             continue;
           }
           const buffer2 = readFileSync97(pathOrFileId);
-          const filename = basename31(pathOrFileId);
+          const filename = basename32(pathOrFileId);
           parts.push(Buffer.from(`--${boundary}\r
 `));
           parts.push(Buffer.from(
@@ -633868,7 +635239,7 @@ __export(projects_exports, {
 });
 import { readFileSync as readFileSync99, writeFileSync as writeFileSync64, mkdirSync as mkdirSync70, existsSync as existsSync121, statSync as statSync44, renameSync as renameSync7 } from "node:fs";
 import { homedir as homedir45 } from "node:os";
-import { basename as basename32, join as join135, resolve as resolve48 } from "node:path";
+import { basename as basename33, join as join135, resolve as resolve48 } from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
 function readAll2() {
   try {
@@ -633916,7 +635287,7 @@ function registerProject(root, pid) {
   } else {
     entry = {
       root: canonical,
-      name: basename32(canonical) || canonical,
+      name: basename33(canonical) || canonical,
       firstSeen: now,
       lastSeen: now,
       pid: pid ?? null,
@@ -634856,14 +636227,14 @@ var init_access_policy = __esm({
 });
 
 // packages/cli/src/api/project-preferences.ts
-import { createHash as createHash28 } from "node:crypto";
+import { createHash as createHash30 } from "node:crypto";
 import { existsSync as existsSync122, mkdirSync as mkdirSync71, readFileSync as readFileSync100, renameSync as renameSync8, writeFileSync as writeFileSync65, unlinkSync as unlinkSync26 } from "node:fs";
 import { homedir as homedir46 } from "node:os";
 import { join as join136, resolve as resolve49 } from "node:path";
 import { randomUUID as randomUUID16 } from "node:crypto";
 function projectKey(root) {
   const canonical = resolve49(root);
-  return createHash28("sha256").update(canonical).digest("hex").slice(0, 16);
+  return createHash30("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 function projectDir(root) {
   return join136(PROJECTS_DIR, projectKey(root));
@@ -635916,7 +637287,7 @@ var init_audit_log = __esm({
 // packages/cli/src/api/disk-task-output.ts
 import { open } from "node:fs/promises";
 import { existsSync as existsSync124, mkdirSync as mkdirSync73, statSync as statSync45 } from "node:fs";
-import { dirname as dirname38 } from "node:path";
+import { dirname as dirname39 } from "node:path";
 import * as fsConstants from "node:constants";
 var O_NOFOLLOW2, O_APPEND2, O_CREAT2, O_WRONLY2, OPEN_FLAGS_WRITE, OPEN_MODE, DiskTaskOutput;
 var init_disk_task_output = __esm({
@@ -635935,7 +637306,7 @@ var init_disk_task_output = __esm({
       fileSize = 0;
       constructor(outputPath3) {
         this.path = outputPath3;
-        mkdirSync73(dirname38(outputPath3), { recursive: true });
+        mkdirSync73(dirname39(outputPath3), { recursive: true });
       }
       /** Queue content for async append. Non-blocking. */
       append(chunk) {
@@ -636041,7 +637412,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash29 } from "node:crypto";
+import { createHash as createHash31 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -636104,7 +637475,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash = createHash29("sha1").update(json).digest("hex").slice(0, 16);
+  const hash = createHash31("sha1").update(json).digest("hex").slice(0, 16);
   return `W/"${hash}"`;
 }
 function checkNotModified(req2, res, etag) {
@@ -650048,7 +651419,7 @@ var init_profiles = __esm({
 // packages/cli/src/docker.ts
 import { execSync as execSync57, spawn as spawn31 } from "node:child_process";
 import { existsSync as existsSync132, mkdirSync as mkdirSync78, writeFileSync as writeFileSync70 } from "node:fs";
-import { join as join145, resolve as resolve50, dirname as dirname39 } from "node:path";
+import { join as join145, resolve as resolve50, dirname as dirname40 } from "node:path";
 import { homedir as homedir52 } from "node:os";
 import { fileURLToPath as fileURLToPath17 } from "node:url";
 function getDockerDir() {
@@ -650059,7 +651430,7 @@ function getDockerDir() {
   } catch {
   }
   try {
-    const thisDir = dirname39(fileURLToPath17(import.meta.url));
+    const thisDir = dirname40(fileURLToPath17(import.meta.url));
     return join145(thisDir, "..", "..", "..", "docker");
   } catch {
   }
@@ -650346,7 +651717,7 @@ __export(embedding_workers_exports, {
   startEmbeddingWorkers: () => startEmbeddingWorkers,
   stopEmbeddingWorkers: () => stopEmbeddingWorkers
 });
-import { basename as basename33, join as join146 } from "node:path";
+import { basename as basename34, join as join146 } from "node:path";
 function startEmbeddingWorkers(opts) {
   if (_running) return;
   _running = true;
@@ -650412,7 +651783,7 @@ async function runEmbeddingTask(modality, episodeId, taskId, opts) {
     try {
       if (!_aligner) {
         const stateRoot = process.env.OMNIUS_DIR || process.cwd();
-        const omniusDir = basename33(stateRoot) === ".omnius" ? stateRoot : join146(stateRoot, ".omnius");
+        const omniusDir = basename34(stateRoot) === ".omnius" ? stateRoot : join146(stateRoot, ".omnius");
         const memDir = join146(omniusDir, "memory");
         _aligner = new EmbeddingAligner(
           `${modality}-${emb.length}`,
@@ -650528,12 +651899,12 @@ import * as http5 from "node:http";
 import * as https3 from "node:https";
 import { createRequire as createRequire7 } from "node:module";
 import { fileURLToPath as fileURLToPath18 } from "node:url";
-import { dirname as dirname40, join as join147, resolve as resolve51 } from "node:path";
+import { dirname as dirname41, join as join147, resolve as resolve51 } from "node:path";
 import { homedir as homedir53 } from "node:os";
 import { spawn as spawn32, execSync as execSync58 } from "node:child_process";
 import { mkdirSync as mkdirSync79, writeFileSync as writeFileSync71, readFileSync as readFileSync108, readdirSync as readdirSync47, existsSync as existsSync133, watch as fsWatch4, renameSync as renameSync9, unlinkSync as unlinkSync28 } from "node:fs";
 import { randomBytes as randomBytes27, randomUUID as randomUUID17 } from "node:crypto";
-import { createHash as createHash31 } from "node:crypto";
+import { createHash as createHash33 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
   const dir = join147(baseDir, ".omnius");
   return {
@@ -650544,7 +651915,7 @@ function memoryDbPaths3(baseDir = process.cwd()) {
 }
 function getVersion3() {
   try {
-    const thisDir = dirname40(fileURLToPath18(import.meta.url));
+    const thisDir = dirname41(fileURLToPath18(import.meta.url));
     const candidates = [
       join147(thisDir, "..", "package.json"),
       join147(thisDir, "..", "..", "package.json"),
@@ -653160,7 +654531,7 @@ async function handleV1Update(req2, res, requestId) {
     }, { subject: req2._authUser ?? "anonymous" });
     const fs11 = require4("node:fs");
     const nodeBin = process.execPath;
-    const nodeDir = dirname40(nodeBin);
+    const nodeDir = dirname41(nodeBin);
     const { execSync: es } = require4("node:child_process");
     const isWin2 = process.platform === "win32";
     let npmBin = "";
@@ -653175,7 +654546,7 @@ async function handleV1Update(req2, res, requestId) {
     const dir = join147(homedir53(), ".omnius");
     fs11.mkdirSync(dir, { recursive: true });
     const logFd = fs11.openSync(logPath3, "w");
-    const npmPrefix = dirname40(nodeDir);
+    const npmPrefix = dirname41(nodeDir);
     let globalBinDir = "";
     try {
       if (isWin2) {
@@ -656455,7 +657826,7 @@ function listScheduledTasks() {
               const schedule = String(t2?.schedule || t2?.cron || t2?.when || "");
               const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
               const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-              const fallbackId = createHash31("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+              const fallbackId = createHash33("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
               const uid = realId || fallbackId;
               const key = `${uid}`;
               if (seen.has(key)) return;
@@ -656572,8 +657943,8 @@ function deleteScheduledById(id) {
     if (id) candidates.push(id);
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id)) candidates.push(entry.id);
     try {
-      const { createHash: createHash32 } = require4("node:crypto");
-      const fallback = createHash32("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash34 } = require4("node:crypto");
+      const fallback = createHash34("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -658349,7 +659720,7 @@ var init_clipboard_media = __esm({
 
 // packages/cli/src/tui/interactive.ts
 import { cwd } from "node:process";
-import { resolve as resolve52, join as join149, dirname as dirname41, extname as extname17, relative as relative14 } from "node:path";
+import { resolve as resolve52, join as join149, dirname as dirname42, extname as extname17, relative as relative14 } from "node:path";
 import { createRequire as createRequire8 } from "node:module";
 import { fileURLToPath as fileURLToPath19 } from "node:url";
 import {
@@ -658376,7 +659747,7 @@ function formatTimeAgo2(date) {
 function getVersion4() {
   try {
     const require5 = createRequire8(import.meta.url);
-    const thisDir = dirname41(fileURLToPath19(import.meta.url));
+    const thisDir = dirname42(fileURLToPath19(import.meta.url));
     const candidates = [
       join149(thisDir, "..", "package.json"),
       join149(thisDir, "..", "..", "package.json"),
@@ -666547,13 +667918,13 @@ NEW TASK: ${fullInput}`;
       writeContent(() => renderError(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash32 } = await import("node:crypto");
+          const { createHash: createHash34 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash32("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash34("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,
@@ -668338,7 +669709,7 @@ init_typed_node_events();
 import { createRequire as createRequire9 } from "node:module";
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { fileURLToPath as fileURLToPath20 } from "node:url";
-import { dirname as dirname42, join as join153 } from "node:path";
+import { dirname as dirname43, join as join153 } from "node:path";
 
 // packages/cli/src/cli.ts
 init_typed_node_events();
@@ -668486,7 +669857,7 @@ try {
 function getVersion5() {
   try {
     const require5 = createRequire9(import.meta.url);
-    const pkgPath = join153(dirname42(fileURLToPath20(import.meta.url)), "..", "package.json");
+    const pkgPath = join153(dirname43(fileURLToPath20(import.meta.url)), "..", "package.json");
     const pkg = require5(pkgPath);
     return pkg.version;
   } catch {