omnius 1.0.154 → 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(),
   };
 }
 
@@ -12170,6 +12251,298 @@ function _readJson(path, fallback) {
 function _writeJson(path, value) {
   try { writeFileSync(path, JSON.stringify(value, null, 2)); } catch {}
 }
+const cohereEndpointCatalogFile = join(nexusDir, 'cohere-endpoint-catalog.json');
+var _cohereEndpointCatalog = {
+  source: 'ollama',
+  passthrough: false,
+  endpointUrl: process.env.OLLAMA_HOST || process.env.OLLAMA_URL || 'http://localhost:11434',
+  endpointAuth: '',
+  models: [],
+  pricingMenu: [],
+  updatedAt: 0,
+};
+function _cohereRedactUrl(url) {
+  var raw = String(url || '').trim();
+  if (!raw) return '';
+  try {
+    var u = new URL(raw);
+    u.username = '';
+    u.password = '';
+    u.search = '';
+    u.hash = '';
+    return u.toString().replace(/\\/+$/, '');
+  } catch {
+    return raw.replace(/([?&](?:api[_-]?key|key|token|auth)=)[^&]+/ig, '$1***');
+  }
+}
+function _cohereNormalizeBaseUrl(rawUrl, passthrough) {
+  var raw = String(rawUrl || '').trim() || 'http://localhost:11434';
+  if (!passthrough) return raw.replace(/\\/+$/, '');
+  return raw
+    .replace(/\\/+$/, '')
+    .replace(/\\/chat\\/completions$/, '')
+    .replace(/\\/completions$/, '')
+    .replace(/\\/models(\\/.*)?$/, '')
+    .replace(/\\/v1$/, '')
+    .replace(/\\/+$/, '');
+}
+function _cohereNormalizeModelRecord(model, source, passthrough) {
+  if (!model) return null;
+  var name = String(model.name || model.model || model.id || '').trim();
+  if (!name) return null;
+  var details = model.details || {};
+  return {
+    name: name,
+    size: Number(model.size || 0) || 0,
+    family: String(model.family || details.family || model.owned_by || ''),
+    parameterSize: String(model.parameterSize || details.parameter_size || ''),
+    quantization: String(model.quantization || details.quantization_level || ''),
+    source: source || (passthrough ? 'openai-compatible' : 'ollama'),
+    passthrough: !!passthrough,
+  };
+}
+function _cohereModelLooksChatCapable(model) {
+  var name = String(model && model.name || '').toLowerCase();
+  var family = String(model && model.family || '').toLowerCase();
+  var text = name + ' ' + family;
+  if (!name) return false;
+  if (/embed|embedding|rerank|nomic-bert|bge-|e5-|clip|whisper|tts|audio/i.test(text)) return false;
+  if (/image|flux|stable.?diffusion|sdxl|dall|midjourney|vision-encoder/i.test(text)) return false;
+  return true;
+}
+function _cohereChatScore(model) {
+  var name = String(model && model.name || '').toLowerCase();
+  var family = String(model && model.family || '').toLowerCase();
+  var score = 1;
+  if (/qwen3\\.5|qwen35|qwen3/i.test(name + ' ' + family)) score = 10;
+  else if (/gpt-|claude|gemini|deepseek|llama|mistral|mixtral|command-r|nemotron|gemma/i.test(name + ' ' + family)) score = 8;
+  else if (/chat|instruct|turbo|sonnet|opus|haiku/i.test(name + ' ' + family)) score = 6;
+  if (/^omnius-/i.test(name)) score += 3;
+  if (model && model.passthrough) score += 1;
+  return score;
+}
+function _cohereAnnotateModels(models, source, passthrough) {
+  var out = [];
+  var input = Array.isArray(models) ? models : [];
+  for (var i = 0; i < input.length; i++) {
+    var rec = _cohereNormalizeModelRecord(input[i], source, passthrough);
+    if (!rec || !_cohereModelLooksChatCapable(rec)) continue;
+    rec._chatScore = _cohereChatScore(rec);
+    out.push(rec);
+  }
+  return out;
+}
+function _cohereApplyAllowlist(models) {
+  if (!_cohereAllowedModels) return Array.isArray(models) ? models : [];
+  return (Array.isArray(models) ? models : []).filter(function(m) { return _cohereAllowedModels.has(m.name); });
+}
+function _coherePersistEndpointCatalog() {
+  var pub = _cohereEndpointSnapshot(_cohereEndpointCatalog);
+  pub.models = (_cohereEndpointCatalog.models || []).map(function(m) {
+    return {
+      name: m.name,
+      size: m.size || 0,
+      family: m.family || '',
+      parameterSize: m.parameterSize || '',
+      quantization: m.quantization || '',
+      source: m.source || _cohereEndpointCatalog.source,
+      passthrough: !!m.passthrough,
+    };
+  });
+  pub.pricingMenu = Array.isArray(_cohereEndpointCatalog.pricingMenu) ? _cohereEndpointCatalog.pricingMenu : [];
+  _writeJson(cohereEndpointCatalogFile, pub);
+}
+function _cohereRememberEndpointCatalog(opts) {
+  opts = opts || {};
+  var passthrough = opts.passthrough === true;
+  var source = String(opts.source || (passthrough ? 'openai-compatible' : 'ollama'));
+  var endpointUrl = _cohereNormalizeBaseUrl(opts.endpointUrl || opts.ollamaUrl || process.env.OLLAMA_HOST || process.env.OLLAMA_URL || 'http://localhost:11434', passthrough);
+  var models = _cohereAnnotateModels(opts.models || [], source, passthrough);
+  _cohereEndpointCatalog = {
+    source: source,
+    passthrough: passthrough,
+    endpointUrl: endpointUrl,
+    endpointAuth: String(opts.endpointAuth || ''),
+    models: models,
+    pricingMenu: Array.isArray(opts.pricingMenu) ? opts.pricingMenu : [],
+    updatedAt: Date.now(),
+  };
+  _coherePersistEndpointCatalog();
+  dlog('COHERE endpoint catalog updated: source=' + source + ' passthrough=' + passthrough + ' models=' + models.length);
+  return _cohereEndpointCatalog;
+}
+function _cohereLoadPersistedEndpointCatalog() {
+  var stored = _readJson(cohereEndpointCatalogFile, null);
+  if (!stored || !Array.isArray(stored.models)) return null;
+  return {
+    source: String(stored.source || 'cached'),
+    passthrough: stored.passthrough === true,
+    endpointUrl: String(stored.endpointUrl || ''),
+    endpointAuth: '',
+    models: _cohereAnnotateModels(stored.models, String(stored.source || 'cached'), stored.passthrough === true),
+    pricingMenu: Array.isArray(stored.pricingMenu) ? stored.pricingMenu : [],
+    updatedAt: Number(stored.updatedAt || 0) || 0,
+    cachedOnly: true,
+  };
+}
+async function _cohereFetchEndpointCatalog(baseUrl, endpointAuth, passthrough) {
+  var endpointUrl = _cohereNormalizeBaseUrl(baseUrl, passthrough);
+  if (passthrough) {
+    var headers = { 'Content-Type': 'application/json' };
+    if (endpointAuth) headers['Authorization'] = 'Bearer ' + endpointAuth;
+    var resp = await fetch(endpointUrl + '/v1/models', { headers: headers, signal: AbortSignal.timeout(10000) });
+    if (!resp.ok) throw new Error('/v1/models HTTP ' + resp.status);
+    var data = await resp.json();
+    var list = Array.isArray(data.data) ? data.data : (Array.isArray(data.models) ? data.models : []);
+    return {
+      source: 'openai-compatible',
+      passthrough: true,
+      endpointUrl: endpointUrl,
+      endpointAuth: String(endpointAuth || ''),
+      models: _cohereAnnotateModels(list.map(function(m) {
+        return {
+          name: m.id || m.name || m.model,
+          family: m.owned_by || m.family || '',
+          size: m.size || 0,
+        };
+      }), 'openai-compatible', true),
+      pricingMenu: [],
+      updatedAt: Date.now(),
+    };
+  }
+  var tagsResp = await fetch(endpointUrl + '/api/tags', { signal: AbortSignal.timeout(10000) });
+  if (!tagsResp.ok) throw new Error('/api/tags HTTP ' + tagsResp.status);
+  var tags = await tagsResp.json();
+  return {
+    source: 'ollama',
+    passthrough: false,
+    endpointUrl: endpointUrl,
+    endpointAuth: '',
+    models: _cohereAnnotateModels(tags.models || [], 'ollama', false),
+    pricingMenu: [],
+    updatedAt: Date.now(),
+  };
+}
+async function _cohereGetModelCatalog(opts) {
+  opts = opts || {};
+  var now = Date.now();
+  var active = _cohereEndpointCatalog;
+  if (!opts.forceRefresh && active && active.models && active.models.length > 0 && now - (active.updatedAt || 0) < 60000) {
+    return active;
+  }
+  if (active && active.endpointUrl && (!active.cachedOnly || active.endpointAuth || !active.passthrough)) {
+    try {
+      var fresh = await _cohereFetchEndpointCatalog(active.endpointUrl, active.endpointAuth || '', !!active.passthrough);
+      fresh.pricingMenu = Array.isArray(active.pricingMenu) ? active.pricingMenu : [];
+      _cohereEndpointCatalog = fresh;
+      _coherePersistEndpointCatalog();
+      return _cohereEndpointCatalog;
+    } catch (err) {
+      dlog('COHERE endpoint catalog refresh failed: ' + (err.message || err));
+      if (active.models && active.models.length > 0) return active;
+    }
+  }
+  var persisted = _cohereLoadPersistedEndpointCatalog();
+  if (persisted && persisted.models && persisted.models.length > 0) return persisted;
+  try {
+    var fallback = await _cohereFetchEndpointCatalog(process.env.OLLAMA_HOST || process.env.OLLAMA_URL || 'http://localhost:11434', '', false);
+    _cohereEndpointCatalog = fallback;
+    _coherePersistEndpointCatalog();
+    return _cohereEndpointCatalog;
+  } catch (err2) {
+    dlog('COHERE local Ollama catalog unavailable: ' + (err2.message || err2));
+  }
+  return Object.assign({}, active || {}, { models: [] });
+}
+function _cohereEndpointSnapshot(catalog) {
+  var c = catalog || _cohereEndpointCatalog || {};
+  return {
+    source: String(c.source || 'unknown'),
+    passthrough: c.passthrough === true,
+    endpointUrl: _cohereRedactUrl(c.endpointUrl || ''),
+    modelCount: Array.isArray(c.models) ? c.models.length : 0,
+    updatedAt: Number(c.updatedAt || 0) || 0,
+    cachedOnly: c.cachedOnly === true,
+  };
+}
+function _cohereSelectModel(catalog, tier) {
+  var models = _cohereApplyAllowlist(catalog && catalog.models || []);
+  if (models.length === 0) return { model: '', models: [] };
+  var passthrough = catalog && catalog.passthrough === true;
+  var gb = 1024 * 1024 * 1024;
+  var maxThresh = tier === 0 ? 8 * gb : tier === 1 ? 50 * gb : tier === 2 ? 100 * gb : Infinity;
+  var minSize = tier === 0 ? 0 : tier === 1 ? 4 * gb : tier === 2 ? 12 * gb : 25 * gb;
+  models.sort(function(a, b) {
+    var sa = a._chatScore || 1, sb = b._chatScore || 1;
+    if (sa !== sb) return sb - sa;
+    return (a.size || 0) - (b.size || 0);
+  });
+  var selected = '';
+  if (_cLastModel) {
+    var warm = models.find(function(m) { return m.name === _cLastModel; });
+    if (warm && (passthrough || ((warm.size || 0) >= minSize && (warm.size || 0) <= maxThresh))) selected = warm.name;
+  }
+  if (!selected) {
+    var fit = passthrough
+      ? models
+      : models.filter(function(m) { return (m.size || 0) >= minSize && (m.size || 0) <= maxThresh; });
+    selected = fit.length > 0 ? fit[0].name : '';
+  }
+  if (!selected && models.length > 0) selected = models[0].name;
+  return { model: selected, models: models };
+}
+async function _cohereDirectEndpointFallback(catalog, model, requestData) {
+  if (!catalog || catalog.passthrough !== true || !catalog.endpointUrl) {
+    throw new Error('No passthrough endpoint is active for direct COHERE fallback');
+  }
+  var headers = { 'Content-Type': 'application/json' };
+  if (catalog.endpointAuth) headers['Authorization'] = 'Bearer ' + catalog.endpointAuth;
+  var messages = [];
+  if (requestData && Array.isArray(requestData.messages) && requestData.messages.length > 0) {
+    messages = requestData.messages;
+  } else {
+    messages = [{ role: 'user', content: String(requestData && requestData.query || '') }];
+  }
+  var maxTokens = Number(requestData && (requestData.maxTokens || requestData.max_tokens)) || 1024;
+  var temperature = Number(requestData && requestData.temperature);
+  var body = {
+    model: model,
+    messages: messages,
+    stream: false,
+    max_tokens: maxTokens > 0 ? maxTokens : 1024,
+    temperature: Number.isFinite(temperature) ? temperature : 0.2,
+    think: false,
+  };
+  var resp = await fetch(_cohereNormalizeBaseUrl(catalog.endpointUrl, true) + '/v1/chat/completions', {
+    method: 'POST',
+    headers: headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(120000),
+  });
+  if (!resp.ok) {
+    var errText = '';
+    try { errText = await resp.text(); } catch {}
+    throw new Error('passthrough /v1/chat/completions HTTP ' + resp.status + ': ' + errText.slice(0, 200));
+  }
+  var data = await resp.json();
+  var choices = data.choices || [];
+  var first = choices[0] && choices[0].message ? choices[0].message : {};
+  var content = String(first.content || first.reasoning || '').replace(/<think>[\\s\\S]*?<\\/think>/g, '').trim();
+  var usage = data.usage || {};
+  return {
+    content: content,
+    usage: {
+      inputTokens: usage.prompt_tokens || usage.input_tokens || 0,
+      outputTokens: usage.completion_tokens || usage.output_tokens || 0,
+    },
+  };
+}
+try {
+  var _cohereStartupCatalog = _cohereLoadPersistedEndpointCatalog();
+  if (_cohereStartupCatalog && _cohereStartupCatalog.models && _cohereStartupCatalog.models.length > 0) {
+    _cohereEndpointCatalog = _cohereStartupCatalog;
+  }
+} catch {}
 async function _dhtPutBounded(dht, key, value, label) {
   var op = (async function() {
     for await (var _ of dht.put(key, value)) {}
@@ -12624,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',
@@ -12631,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: {
@@ -12715,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]' });
@@ -13556,7 +13937,20 @@ async function handleCmd(cmd) {
 
         // WO-1.5: Publish capacity announcement on enable
         if (typeof _publishCapacityAnnouncement === 'function') {
-          try { _publishCapacityAnnouncement(); } catch {}
+          try { await _publishCapacityAnnouncement(); } catch {}
+        }
+        try {
+          var _ceCatalog = await _cohereGetModelCatalog({});
+          await _publishCapabilityRecord('cohere_inference', {
+            description: 'COHERE distributed inference provider',
+            pricing: 'free',
+            rateLimit: _sponsorLimits ? String(_sponsorLimits.maxRequestsPerMinute) + '/min' : 'provider-policy',
+            endpoint: _cohereEndpointSnapshot(_ceCatalog),
+            models: (_ceCatalog.models || []).map(function(m) { return m.name; }),
+            passthrough: _ceCatalog.passthrough === true,
+          });
+        } catch (_cePubErr) {
+          dlog('COHERE capability publish failed: ' + (_cePubErr.message || _cePubErr));
         }
         writeResp(id, { ok: true, output: 'COHERE inference handler enabled' });
         break;
@@ -13589,7 +13983,8 @@ async function handleCmd(cmd) {
           bytesOut: _cohereStats.bytesOut,
           modelsUsed: _cohereStats.modelsUsed,
           peersServed: _cohereStats.peersServed,
-          allowedModels: _cohereAllowedModels ? [..._cohereAllowedModels] : null
+          allowedModels: _cohereAllowedModels ? [..._cohereAllowedModels] : null,
+          endpoint: _cohereEndpointSnapshot(),
         };
         if (args.format === 'json' || args.json === true || args.json === 'true' || args.json === '1') {
           writeResp(id, { ok: true, output: JSON.stringify(_csSnapshot) });
@@ -13627,9 +14022,15 @@ async function handleCmd(cmd) {
           _csLines.push('  ' + _csPeers[_cpi][0].slice(0, 20) + '...: ' + _csPeers[_cpi][1] + ' queries');
         }
         _csLines.push('');
+        _csLines.push('── Endpoint ──');
+        var _csEndpoint = _cohereEndpointSnapshot();
+        _csLines.push('  Source: ' + _csEndpoint.source + (_csEndpoint.passthrough ? ' (passthrough)' : ''));
+        _csLines.push('  URL: ' + (_csEndpoint.endpointUrl || '(not set)'));
+        _csLines.push('  Models: ' + _csEndpoint.modelCount + (_csEndpoint.cachedOnly ? ' (cached)' : ''));
+        _csLines.push('');
         _csLines.push('── Model Allowlist ──');
         if (!_cohereAllowedModels) {
-          _csLines.push('  All downloaded models exposed (no filter)');
+          _csLines.push('  All endpoint models exposed (no filter)');
         } else {
           _csLines.push('  ' + [..._cohereAllowedModels].join(', '));
         }
@@ -13659,21 +14060,36 @@ async function handleCmd(cmd) {
         break;
       }
       case 'cohere_list_models': {
-        var _clmOllamaUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
-        var _clmModels = [];
-        try {
-          var _clmResp = await fetch(_clmOllamaUrl + '/api/tags');
-          var _clmData = await _clmResp.json();
-          _clmModels = (_clmData.models || []).map(function(m) { return { name: m.name, size: m.size || 0, family: m.details?.family || '' }; });
-        } catch {}
-        var _clmLines = ['── Downloaded Models ──'];
+        var _clmCatalog = await _cohereGetModelCatalog({ forceRefresh: args.refresh === 'true' || args.refresh === true || args.refresh === '1' });
+        var _clmModels = Array.isArray(_clmCatalog.models) ? _clmCatalog.models : [];
+        var _clmPayload = {
+          models: _clmModels.map(function(m) { return m.name; }),
+          exposedModels: _cohereApplyAllowlist(_clmModels).map(function(m) { return m.name; }),
+          modelDetails: _clmModels.map(function(m) {
+            return Object.assign({}, m, { exposed: !_cohereAllowedModels || _cohereAllowedModels.has(m.name) });
+          }),
+          source: _clmCatalog.source || 'unknown',
+          passthrough: _clmCatalog.passthrough === true,
+          endpoint: _cohereEndpointSnapshot(_clmCatalog),
+          allowedModels: _cohereAllowedModels ? [..._cohereAllowedModels] : null,
+        };
+        if (args.format === 'json' || args.json === true || args.json === 'true' || args.json === '1') {
+          writeResp(id, { ok: true, output: JSON.stringify(_clmPayload) });
+          break;
+        }
+        var _clmLines = ['── Endpoint Models ──'];
+        var _clmEndpoint = _cohereEndpointSnapshot(_clmCatalog);
+        _clmLines.push('  Source: ' + _clmEndpoint.source + (_clmEndpoint.passthrough ? ' (passthrough)' : ''));
+        _clmLines.push('  URL: ' + (_clmEndpoint.endpointUrl || '(not set)'));
+        _clmLines.push('');
         for (var _clmi = 0; _clmi < _clmModels.length; _clmi++) {
           var _clmM = _clmModels[_clmi];
           var _clmAllowed = !_cohereAllowedModels || _cohereAllowedModels.has(_clmM.name);
           var _clmSizeGB = (_clmM.size / (1024*1024*1024)).toFixed(1);
-          _clmLines.push('  ' + (_clmAllowed ? '[EXPOSED]' : '[HIDDEN] ') + ' ' + _clmM.name + ' (' + _clmSizeGB + 'GB' + (_clmM.family ? ', ' + _clmM.family : '') + ')');
+          var _clmMeta = _clmM.size > 0 ? _clmSizeGB + 'GB' : (_clmM.passthrough ? 'external' : 'size unknown');
+          _clmLines.push('  ' + (_clmAllowed ? '[EXPOSED]' : '[HIDDEN] ') + ' ' + _clmM.name + ' (' + _clmMeta + (_clmM.family ? ', ' + _clmM.family : '') + ')');
         }
-        if (_clmModels.length === 0) _clmLines.push('  (no models found — is Ollama running?)');
+        if (_clmModels.length === 0) _clmLines.push('  (no endpoint models found — check /endpoint and /expose passthrough)');
         _clmLines.push('');
         _clmLines.push(_cohereAllowedModels ? 'Allowlist: ' + [..._cohereAllowedModels].join(', ') : 'Allowlist: ALL (no filter active)');
         writeResp(id, { ok: true, output: _clmLines.join('\\n') });
@@ -13856,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 {}
             }
           }
@@ -13890,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';
@@ -14392,6 +14820,32 @@ async function handleCmd(cmd) {
           }
         }
 
+        var _exCohereCatalog = _cohereRememberEndpointCatalog({
+          source: isPassthrough ? 'openai-compatible' : 'ollama',
+          passthrough: isPassthrough,
+          endpointUrl: ollamaUrl,
+          endpointAuth: endpointAuth,
+          models: models,
+          pricingMenu: pricingMenu,
+        });
+        if (cohereActive) {
+          try {
+            await _publishCapabilityRecord('cohere_inference', {
+              description: 'COHERE distributed inference provider',
+              pricing: 'free',
+              rateLimit: _sponsorLimits ? String(_sponsorLimits.maxRequestsPerMinute) + '/min' : 'provider-policy',
+              endpoint: _cohereEndpointSnapshot(_exCohereCatalog),
+              models: (_exCohereCatalog.models || []).map(function(m) { return m.name; }),
+              passthrough: isPassthrough,
+            });
+          } catch (_exCoherePubErr) {
+            dlog('COHERE expose capability publish failed: ' + (_exCoherePubErr.message || _exCoherePubErr));
+          }
+          if (typeof _publishCapacityAnnouncement === 'function') {
+            try { await _publishCapacityAnnouncement(); } catch {}
+          }
+        }
+
         for (var pci = 0; pci < pricingMenu.length; pci++) {
           var capPricing = pricingMenu[pci];
           await _publishCapabilityRecord('inference:' + capPricing.model.replace(/[^a-zA-Z0-9._-]/g, '_'), {
@@ -14409,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) => {
@@ -14539,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();
@@ -14557,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:'];
@@ -14572,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');
@@ -15340,13 +16025,12 @@ process.on('unhandledRejection', (reason) => {
     }
 
     // ── COHERE distributed inference handler ─────────────────────────
-    // ── COHERE distributed inference handler ─────────────────────────
-    // Subscribe to nexus.cohere.query, process through local Ollama,
-    // publish response to nexus.cohere.response.
+    // Subscribe to nexus.cohere.query, process through the active Omnius
+    // endpoint catalog, publish response to nexus.cohere.response.
     // SECURITY INVARIANTS:
     //   1. Handler constructs ISOLATED messages — no history, no system prompt
-    //   2. Only /api/tags (read model list) and /api/chat (inference) are called
-    //   3. NEVER calls /api/pull, /api/delete, /api/push, /api/create, /api/copy
+    //   2. Model discovery is read-only: /api/tags or /v1/models
+    //   3. Inference uses /v1/run first; direct fallback is passthrough-only
     //   4. Model allowlist filters which models are served to remote queries
     //   5. Inbound queries scanned for leaked secrets
     if (_natsConn && _natsCodec) {
@@ -15534,89 +16218,34 @@ process.on('unhandledRejection', (reason) => {
             dlog('COHERE query: ' + _cData.queryId + ' — ' + (_cData.query || '').slice(0, 80) + ' [elected, score=' + _cBidScore.toFixed(2) + ', bids=' + _cBids.size + ']');
             const _cStart = Date.now();
 
-            // OLLAMA SAFETY: Only two endpoints are ever called:
-            //   GET  /api/tags  — read available models (READ-ONLY)
-            //   POST /api/chat  — run inference on existing model (READ-ONLY)
+            // Endpoint safety: COHERE model discovery is read-only.
+            //   Ollama providers: GET /api/tags only
+            //   Passthrough providers: GET /v1/models only
+            // Remote COHERE queries never call Ollama model-management endpoints.
             // The following are NEVER called from remote requests:
             //   POST /api/pull    — download model (BLOCKED)
             //   DELETE /api/delete — remove model (BLOCKED)
             //   POST /api/push    — upload model (BLOCKED)
             //   POST /api/create  — create model (BLOCKED)
             //   POST /api/copy    — copy model (BLOCKED)
-            const _cOllamaUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
+            var _cCatalog = null;
             let _cModel = '';
             try {
-              const _cTags = await fetch(_cOllamaUrl + '/api/tags').then(function(r) { return r.json(); });
-              // Filter out non-chat models: embeddings, image generators, vision-only
-              // Use family/families from Ollama model cards for capability detection
-              var _cAllModels = (_cTags.models || []).filter(function(m) {
-                var name = (m.name || '').toLowerCase();
-                var family = ((m.details && m.details.family) || '').toLowerCase();
-                var families = (m.details && m.details.families) || [];
-                var famStr = families.join(' ').toLowerCase();
-                // Exclude embeddings
-                if (/embed|nomic-bert/i.test(name) || /embed|nomic-bert/i.test(family)) return false;
-                // Exclude image generation models (flux, sd, sdxl, image-turbo, etc.)
-                if (/image|flux|stable.?diffusion|sdxl|sd[0-9]|dall|turbo.*image|image.*turbo/i.test(name)) return false;
-                if (/flux|diffusion/i.test(family)) return false;
-                // Exclude pure vision models (keep multimodal like qwen3-vl that also do chat)
-                if (/^clip$|^vit$/i.test(family)) return false;
-                return true;
-              });
-              // Score models for chat/tool capability: prefer qwen, then tool-capable families
-              var _cChatFamilies = { qwen35: 10, qwen35moe: 10, qwen3: 9, qwen3moe: 9, qwen3next: 9, nemotron_h_moe: 8, mistral3: 7, llama: 6, gemma3: 6, seed_oss: 5, phi2: 3 };
-              for (var _cmi = 0; _cmi < _cAllModels.length; _cmi++) {
-                var _cmFam = ((_cAllModels[_cmi].details && _cAllModels[_cmi].details.family) || '').toLowerCase();
-                _cAllModels[_cmi]._chatScore = _cChatFamilies[_cmFam] || 1;
-                // Boost omnius- prefixed models (known good configs)
-                if (/^omnius-/i.test(_cAllModels[_cmi].name)) _cAllModels[_cmi]._chatScore += 3;
-              }
-              // Apply model allowlist — only serve allowed models to remote queries
-              var _cModels = _cohereAllowedModels
-                ? _cAllModels.filter(function(m) { return _cohereAllowedModels.has(m.name); })
-                : _cAllModels;
+              _cCatalog = await _cohereGetModelCatalog({});
+              var _cSelected = _cohereSelectModel(_cCatalog, _cTier);
+              var _cModels = _cSelected.models || [];
               if (_cModels.length === 0 && _cohereAllowedModels) {
-                dlog('COHERE: no allowed models match downloaded models. Allowlist: ' + [..._cohereAllowedModels].join(', '));
+                dlog('COHERE: no allowed models match endpoint catalog. Allowlist: ' + [..._cohereAllowedModels].join(', '));
                 _cohereStats.queriesErrors++;
                 _saveStats();
                 continue;
               }
-              // CO-04/05: Model selection — tier determines minimum size, warm gets priority within tier
-              var _cGB = 1024 * 1024 * 1024;
-              // Tier thresholds: [max for trivial, max for moderate, max for complex, unlimited]
-              var _cMaxThresh = _cTier === 0 ? 8 * _cGB : _cTier === 1 ? 50 * _cGB : _cTier === 2 ? 100 * _cGB : Infinity;
-              // Minimum size: higher tiers REQUIRE bigger models
-              var _cMinSize = _cTier === 0 ? 0 : _cTier === 1 ? 4 * _cGB : _cTier === 2 ? 12 * _cGB : 25 * _cGB;
-
-              // Sort by chat capability score (desc), then size within same score (asc)
-              _cModels.sort(function(a, b) {
-                var sa = a._chatScore || 1, sb = b._chatScore || 1;
-                if (sa !== sb) return sb - sa; // higher chat score first
-                return (a.size || 0) - (b.size || 0); // then smaller first within same score
-              });
-
-              // Prefer warm model ONLY if it meets the minimum size for this tier
-              if (_cLastModel) {
-                var _cWarm = _cModels.find(function(m) { return m.name === _cLastModel; });
-                if (_cWarm && (_cWarm.size || 0) >= _cMinSize && (_cWarm.size || 0) <= _cMaxThresh) {
-                  _cModel = _cWarm.name;
-                }
-              }
-              // Otherwise pick best-scored model that fits the tier range
-              // Models already sorted by chatScore desc, so first match is best
-              if (!_cModel) {
-                var _cFit = _cModels.filter(function(m) { return (m.size || 0) >= _cMinSize && (m.size || 0) <= _cMaxThresh; });
-                // Pick the one with highest chat score (already sorted)
-                _cModel = _cFit.length > 0 ? _cFit[0].name : '';
-              }
-              // Fallback: if no model fits the range, take the best-scored available
-              if (!_cModel && _cModels.length > 0) {
-                _cModel = _cModels[0].name; // first = highest chatScore
-                dlog('COHERE: no model fits tier ' + _cTier + ' range [' + (_cMinSize / _cGB).toFixed(0) + 'GB-' + (_cMaxThresh / _cGB).toFixed(0) + 'GB], using best-scored: ' + _cModel);
-              }
-              dlog('COHERE routing: tier=' + ['trivial','moderate','complex','expert'][_cTier] + ' model=' + _cModel + ' (chatScore=' + ((_cModels.find(function(m){return m.name===_cModel})||{})._chatScore||'?') + ')');
-            } catch {}
-            if (!_cModel) { dlog('COHERE: no Ollama models available'); _cohereStats.queriesErrors++; _saveStats(); continue; }
+              _cModel = _cSelected.model || '';
+              dlog('COHERE routing: source=' + ((_cCatalog && _cCatalog.source) || 'unknown') + ' passthrough=' + (!!(_cCatalog && _cCatalog.passthrough)) + ' tier=' + ['trivial','moderate','complex','expert'][_cTier] + ' model=' + _cModel + ' (chatScore=' + ((_cModels.find(function(m){return m.name===_cModel})||{})._chatScore||'?') + ')');
+            } catch (_cCatalogErr) {
+              dlog('COHERE catalog error: ' + (_cCatalogErr.message || _cCatalogErr));
+            }
+            if (!_cModel) { dlog('COHERE: no endpoint models available'); _cohereStats.queriesErrors++; _saveStats(); continue; }
             try {
               // Scan inbound query for leaked secrets (defense-in-depth)
               const _cSecretPatterns = [/sk-[a-zA-Z0-9]{20,}/g, /ghp_[a-zA-Z0-9]{36,}/g, /AKIA[0-9A-Z]{16}/g];
@@ -15652,6 +16281,10 @@ process.on('unhandledRejection', (reason) => {
               if (_cApiAvailable) {
                 dlog('COHERE: routing through full AgenticRunner at ' + _cApiUrl + '/v1/run');
                 try {
+                  var _cRunEnv = {};
+                  if (_cCatalog && _cCatalog.endpointUrl) _cRunEnv.OMNIUS_BACKEND_URL = _cCatalog.endpointUrl;
+                  if (_cCatalog && _cCatalog.endpointAuth) _cRunEnv.OMNIUS_API_KEY = _cCatalog.endpointAuth;
+                  if (_cModel) _cRunEnv.OMNIUS_MODEL = _cModel;
                   var _cRunResp = await fetch(_cApiUrl + '/v1/run', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
@@ -15662,6 +16295,7 @@ process.on('unhandledRejection', (reason) => {
                       timeout_s: 90,
                       sandbox: 'none',
                       profile: 'cohere-mesh',
+                      env: _cRunEnv,
                     }),
                     signal: AbortSignal.timeout(120000),
                   });
@@ -15701,22 +16335,34 @@ process.on('unhandledRejection', (reason) => {
                   if (_cContent) {
                     dlog('COHERE: AgenticRunner responded (' + _cContent.length + ' chars)');
                   } else {
-                    dlog('COHERE: AgenticRunner returned empty — falling back to raw Ollama');
+                    dlog('COHERE: AgenticRunner returned empty');
                   }
                 } catch (_cRunErr) {
-                  dlog('COHERE: AgenticRunner error: ' + (_cRunErr.message || _cRunErr) + ' — falling back');
+                  dlog('COHERE: AgenticRunner error: ' + (_cRunErr.message || _cRunErr));
                 }
               } else {
-                dlog('COHERE: Omnius API not available at ' + _cApiUrl + ' — CANNOT process query (no raw Ollama fallback)');
-                _cContent = '[COHERE error] Omnius API server not running on this node. Start it with: omnius serve';
+                dlog('COHERE: Omnius API not available at ' + _cApiUrl);
+              }
+
+              // No raw local-Ollama fallback. If the user explicitly exposed an
+              // OpenAI-compatible passthrough endpoint, use that endpoint directly
+              // as a degraded fallback so COHERE still serves external providers.
+              if (!_cContent && _cCatalog && _cCatalog.passthrough === true) {
+                try {
+                  var _cDirect = await _cohereDirectEndpointFallback(_cCatalog, _cModel, _cData);
+                  _cContent = _cDirect.content || '';
+                  _cUsage = _cDirect.usage;
+                  if (_cContent) dlog('COHERE: direct passthrough fallback responded (' + _cContent.length + ' chars)');
+                } catch (_cDirectErr) {
+                  dlog('COHERE: direct passthrough fallback failed: ' + (_cDirectErr.message || _cDirectErr));
+                }
               }
 
-              // NO raw Ollama fallback — all queries MUST go through AgenticRunner
-              // If /v1/run failed or API unavailable, report the error instead of
-              // sending garbage responses without tools/context/system prompt.
               if (!_cContent) {
-                _cContent = '[COHERE error] AgenticRunner returned empty response. Check Omnius API server logs.';
-                dlog('COHERE: no content from AgenticRunner — reporting error (no raw Ollama fallback)');
+                _cContent = _cApiAvailable
+                  ? '[COHERE error] AgenticRunner returned empty response. Check Omnius API server logs.'
+                  : '[COHERE error] Omnius API server not running on this node. Start it with: omnius serve, or expose an OpenAI-compatible endpoint with /expose passthrough.';
+                dlog('COHERE: no content from AgenticRunner or passthrough endpoint');
               }
 
               const _cLatency = Date.now() - _cStart;
@@ -16072,24 +16718,8 @@ process.on('unhandledRejection', (reason) => {
       async function _publishCapacityAnnouncement() {
         if (!cohereActive || !_natsConn || !_natsCodec) return;
         try {
-          var _capOllamaUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
-          var _capModels = [];
-          try {
-            var _capTags = await fetch(_capOllamaUrl + '/api/tags').then(function(r) { return r.json(); });
-            _capModels = (_capTags.models || []).map(function(m) {
-              return {
-                name: m.name,
-                size: m.size || 0,
-                family: m.details ? m.details.family || '' : '',
-                parameterSize: m.details ? m.details.parameter_size || '' : '',
-                quantization: m.details ? m.details.quantization_level || '' : '',
-              };
-            });
-          } catch {}
-          // Filter by allowlist
-          if (_cohereAllowedModels) {
-            _capModels = _capModels.filter(function(m) { return _cohereAllowedModels.has(m.name); });
-          }
+          var _capCatalog = await _cohereGetModelCatalog({});
+          var _capModels = _cohereApplyAllowlist(_capCatalog.models || []);
           var _capMetrics = await _collectSysMetrics();
           // CO-02: Enriched per-model capacity — warm/cold, specialty, estimated latency
           var _capEnriched = _capModels.map(function(m) {
@@ -16122,6 +16752,7 @@ process.on('unhandledRejection', (reason) => {
             agentName: agentName,
             agentType: agentType,
             cohereActive: cohereActive,
+            endpoint: _cohereEndpointSnapshot(_capCatalog),
             models: _capEnriched,
             warmModel: _cLastModel || null,
             modelCount: _capEnriched.length,
@@ -16129,7 +16760,7 @@ process.on('unhandledRejection', (reason) => {
             totalVram: _capTotalVram,
             availableVram: _capAvailVram,
             specialties: _capSpecialties,
-            capabilities: ['inference'],  // future: web_search, code_execution
+            capabilities: ['inference', 'cohere_inference'],
             allowedModels: _cohereAllowedModels ? [..._cohereAllowedModels] : null,
             stats: {
               queriesAnswered: _cohereStats.queriesAnswered,
@@ -16198,6 +16829,7 @@ process.on('unhandledRejection', (reason) => {
               multiaddrs: [],
               timestamp: Date.now(),
               capabilities: _capModels.map(function(m) { return m.name; }),
+              endpoint: _cohereEndpointSnapshot(_capCatalog),
               identityCid: _idCid || undefined,
               identityHash: _idHash || undefined,
               identityVersion: _idVersion || undefined,
@@ -17131,11 +17763,15 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           },
           format: {
             type: "string",
-            description: "For cohere_stats: set to 'json' for structured stats"
+            description: "For cohere_stats/cohere_list_models: set to 'json' for structured output"
           },
           json: {
             type: "string",
-            description: "For cohere_stats: set to '1' for structured stats"
+            description: "For cohere_stats/cohere_list_models: set to '1' for structured output"
+          },
+          refresh: {
+            type: "string",
+            description: "For cohere_list_models: set to '1' to refresh the active endpoint catalog"
           }
         },
         required: ["action"],
@@ -17282,7 +17918,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               result = await this.sendDaemonCmd("cohere_deny_model", { model: String(args.model ?? "") });
               break;
             case "cohere_list_models":
-              result = await this.sendDaemonCmd("cohere_list_models", {});
+              result = await this.sendDaemonCmd("cohere_list_models", { format: String(args.format ?? ""), json: String(args.json ?? ""), refresh: String(args.refresh ?? "") });
               break;
             case "ipfs_add":
               result = await this.sendDaemonCmd("ipfs_add", { content: String(args.content ?? args.message ?? "") });
@@ -95680,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();
@@ -95991,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;
@@ -131910,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();
@@ -132141,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
@@ -238678,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();
@@ -239338,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;
@@ -239705,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();
@@ -240006,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",
@@ -245803,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,
@@ -245827,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
@@ -246328,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);
@@ -249726,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) {
@@ -252813,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 {
@@ -252952,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,
@@ -253035,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 {
@@ -262277,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";
@@ -265619,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)
@@ -266055,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 = {
@@ -270211,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({
@@ -270279,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,
@@ -409783,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;
           }
@@ -473711,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"
@@ -477396,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();
@@ -486278,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);
@@ -486300,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;
@@ -514591,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() {
@@ -514663,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";
@@ -523172,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");
 }
@@ -523213,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");
@@ -524909,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);
 }
@@ -524937,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";
   }
@@ -526593,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,
@@ -526655,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,
@@ -526701,6 +527770,7 @@ __export(dist_exports, {
   aliasTool: () => aliasTool,
   applyPatch: () => applyPatch,
   applyToolResultTriage: () => applyToolResultTriage,
+  artifactManifestFromBytes: () => artifactManifestFromBytes,
   audioGenerationDir: () => audioGenerationDir,
   audioGenerationSetupPlan: () => audioGenerationSetupPlan,
   audioGenerationVenvDir: () => audioGenerationVenvDir,
@@ -526714,6 +527784,7 @@ __export(dist_exports, {
   buildMcpToolName: () => buildMcpToolName,
   buildScaffoldedPrompt: () => buildScaffoldedPrompt,
   buildSkillsSummary: () => buildSkillsSummary,
+  buildSponsorMediaServices: () => buildSponsorMediaServices,
   buildSubProcessArgs: () => buildSubProcessArgs,
   buildToolManifestFromModule: () => buildToolManifestFromModule,
   canInvokeTool: () => canInvokeTool,
@@ -526733,6 +527804,7 @@ __export(dist_exports, {
   createTransport: () => createTransport,
   createWorktree: () => createWorktree2,
   defaultExposureForTool: () => defaultExposureForTool,
+  defaultExtensionForMime: () => defaultExtensionForMime,
   deleteTodos: () => deleteTodos,
   detectElevationMethod: () => detectElevationMethod,
   detectLegacyCaches: () => detectLegacyCaches,
@@ -526824,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,
@@ -526862,6 +527937,7 @@ __export(dist_exports, {
   runTypecheck: () => runTypecheck,
   runValidationPipeline: () => runValidationPipeline,
   sanitizeReminderDeliveryText: () => sanitizeReminderDeliveryText,
+  sanitizeRemoteMediaGenerateRequest: () => sanitizeRemoteMediaGenerateRequest,
   saveCustomToolDefinition: () => saveCustomToolDefinition,
   saveMcpServerToConfig: () => saveMcpServerToConfig,
   savePacket: () => savePacket,
@@ -526875,6 +527951,7 @@ __export(dist_exports, {
   sha256Text: () => sha256Text,
   shannonEntropy: () => shannonEntropy,
   spawnFullSubAgent: () => spawnFullSubAgent,
+  sponsorMediaCapabilityName: () => sponsorMediaCapabilityName,
   stableJson: () => stableJson,
   stopFullSubAgent: () => stopFullSubAgent,
   summarizeLog: () => summarizeLog,
@@ -526962,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();
@@ -531521,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;
@@ -535153,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;
@@ -535371,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);
@@ -535905,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, " ");
@@ -536264,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;
 }
@@ -540397,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,
@@ -540422,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)
@@ -540633,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);
@@ -540695,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();
 }
@@ -540709,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() {
@@ -540891,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}`;
       }
     };
@@ -543402,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 = {};
@@ -543569,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 {
@@ -549831,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",
@@ -563288,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 {
@@ -563307,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;
@@ -565558,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();
@@ -566218,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;
@@ -566585,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();
@@ -566886,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",
@@ -567639,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"],
@@ -571672,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);
@@ -572010,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) {
@@ -572025,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";
@@ -572553,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,
@@ -572568,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()) {
@@ -572766,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();
@@ -572851,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,
@@ -572963,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()) {
@@ -573222,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);
           }
@@ -573726,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
         });
@@ -573791,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) {
@@ -573808,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})`);
@@ -573876,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,
@@ -574014,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()) {
@@ -574040,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;
       }
@@ -574290,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") {
@@ -574325,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);
                     }
@@ -574380,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
         });
@@ -574519,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;
@@ -574764,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);
@@ -574779,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"() {
@@ -574796,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");
@@ -576134,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;
@@ -576588,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);
@@ -591501,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",
@@ -591509,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;
@@ -592150,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)" },
@@ -592176,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,
@@ -592213,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}` },
@@ -592220,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;
@@ -592238,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",
@@ -592298,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: "" },
@@ -592322,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.");
@@ -592340,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;
@@ -592381,6 +593693,7 @@ var init_sponsor_wizard = __esm({
     init_tui_select();
     init_render();
     init_usage_bars();
+    init_dist5();
   }
 });
 
@@ -596567,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,
@@ -596579,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();
@@ -596973,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)) {
@@ -600934,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";
@@ -601180,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}`
           );
@@ -601438,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,
@@ -604995,7 +606332,14 @@ function emptyCohereStats(isActive = false) {
     bytesOut: 0,
     modelsUsed: {},
     peersServed: {},
-    allowedModels: null
+    allowedModels: null,
+    endpoint: {
+      source: "unknown",
+      passthrough: false,
+      endpointUrl: "",
+      modelCount: 0,
+      updatedAt: 0
+    }
   };
 }
 function numberField(value2) {
@@ -605014,6 +606358,7 @@ function parseCohereStatsOutput(output, isActive = false) {
   try {
     const parsed = JSON.parse(output);
     const active = typeof parsed.active === "boolean" ? parsed.active : String(parsed.status ?? "").toLowerCase() === "active";
+    const endpointRaw = parsed.endpoint && typeof parsed.endpoint === "object" ? parsed.endpoint : {};
     return {
       status: active ? "active" : "inactive",
       active,
@@ -605029,7 +606374,15 @@ function parseCohereStatsOutput(output, isActive = false) {
       bytesOut: numberField(parsed.bytesOut),
       modelsUsed: mapNumberRecord(parsed.modelsUsed),
       peersServed: mapNumberRecord(parsed.peersServed),
-      allowedModels: Array.isArray(parsed.allowedModels) ? parsed.allowedModels.map(String) : null
+      allowedModels: Array.isArray(parsed.allowedModels) ? parsed.allowedModels.map(String) : null,
+      endpoint: {
+        source: String(endpointRaw.source ?? "unknown"),
+        passthrough: endpointRaw.passthrough === true,
+        endpointUrl: String(endpointRaw.endpointUrl ?? ""),
+        modelCount: numberField(endpointRaw.modelCount),
+        updatedAt: numberField(endpointRaw.updatedAt),
+        cachedOnly: endpointRaw.cachedOnly === true
+      }
     };
   } catch {
     return emptyCohereStats(isActive);
@@ -605054,10 +606407,11 @@ async function fetchCohereDashboardState(ctx3) {
     } catch {
     }
     try {
-      const r2 = await nexus.execute({ action: "cohere_list_models" });
+      const r2 = await nexus.execute({ action: "cohere_list_models", format: "json" });
       if (r2.success) {
         try {
-          state.modelList = JSON.parse(r2.output).models || [];
+          const parsed = JSON.parse(r2.output);
+          state.modelList = Array.isArray(parsed.models) ? parsed.models.map(String) : [];
         } catch {
           state.modelList = r2.output.split("\n").map((l2) => l2.trim()).filter(Boolean);
         }
@@ -605083,8 +606437,9 @@ function cohereStatusLines(stats, modelList) {
     `Sent out: ${stats.queriesSent} · avg latency ${stats.avgLatencyMs}ms`,
     `Data: in ${formatFileSize(stats.bytesIn)} · out ${formatFileSize(stats.bytesOut)}`,
     "",
-    `Models exposed: ${modelList.length}`,
-    `Allowlist: ${stats.allowedModels ? stats.allowedModels.join(", ") || "(empty)" : "all downloaded models"}`,
+    `Endpoint: ${stats.endpoint.source}${stats.endpoint.passthrough ? " passthrough" : ""}${stats.endpoint.endpointUrl ? ` · ${stats.endpoint.endpointUrl}` : ""}`,
+    `Models available: ${modelList.length || stats.endpoint.modelCount}${stats.endpoint.cachedOnly ? " (cached)" : ""}`,
+    `Allowlist: ${stats.allowedModels ? stats.allowedModels.join(", ") || "(empty)" : "all endpoint models"}`,
     `Top models: ${modelEntries.length ? modelEntries.slice(0, 5).map(([m2, n2]) => `${m2} (${n2})`).join(", ") : "none yet"}`,
     `Peers served: ${peerEntries.length ? peerEntries.slice(0, 5).map(([p2, n2]) => `${p2.slice(0, 20)} (${n2})`).join(", ") : "none yet"}`
   ];
@@ -605098,7 +606453,7 @@ async function showCohereDashboard(ctx3) {
   while (true) {
     const currentActive = ctx3.isCohere?.() ?? false;
     const toggleLabel = currentActive ? "Disable COHERE" : "Enable COHERE";
-    const toggleDetail = currentActive ? `Active — forwarding ${ctx3.config.model}` : "Join the distributed cognitive commons";
+    const toggleDetail = currentActive ? `Active — forwarding ${ctx3.config.model} via current endpoint` : "Join the distributed cognitive commons";
     const items = [
       {
         key: "hdr-status",
@@ -605711,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,
               "-"
             );
@@ -606105,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();
@@ -606118,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}`);
@@ -606602,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 = [];
@@ -606707,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
@@ -606771,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
@@ -607063,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(
@@ -608045,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"),
@@ -609892,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) {
@@ -609973,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 ?? "" });
@@ -610237,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, " ");
 }
@@ -610559,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);
@@ -610604,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);
@@ -610662,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, " ")}`;
 }
@@ -610731,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) {
@@ -610889,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}`,
@@ -611830,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 {
@@ -611926,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);
   }
@@ -613106,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);
@@ -613126,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;
@@ -613136,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;
@@ -613349,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 };
         }
@@ -613384,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 };
         }
@@ -613437,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 };
         }
@@ -613472,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 };
         }
@@ -615073,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;
@@ -615824,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 {
@@ -615878,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;
@@ -616172,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"));
@@ -617655,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,
@@ -617820,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;
@@ -617889,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 } };
@@ -617981,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"),
@@ -618032,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,
@@ -618200,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,
@@ -618702,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";
 }
@@ -618710,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) {
@@ -618795,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;
@@ -619115,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,
@@ -619328,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();
@@ -620063,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}`;
@@ -620087,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;
@@ -620865,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();
@@ -621807,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;
@@ -623422,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, "-")}`;
@@ -624345,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() {
@@ -624577,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"),
@@ -624594,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) : [],
@@ -624796,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) {
@@ -625567,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;
@@ -625604,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;
@@ -625632,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
         };
       }
@@ -625689,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,
@@ -625811,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: [],
@@ -625866,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: [],
@@ -626583,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",
@@ -628008,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) {
@@ -631459,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);
@@ -631591,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: []
@@ -631609,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: []
@@ -632095,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) => {
@@ -632335,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(
@@ -633546,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 {
@@ -633594,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,
@@ -634534,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));
@@ -635594,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({
@@ -635613,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) {
@@ -635719,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",
@@ -635782,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) {
@@ -649726,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() {
@@ -649737,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 {
   }
@@ -650024,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;
@@ -650090,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}`,
@@ -650206,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 {
@@ -650222,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"),
@@ -652838,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 = "";
@@ -652853,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) {
@@ -656133,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;
@@ -656250,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 {
     }
@@ -658027,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 {
@@ -658054,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"),
@@ -663757,7 +665450,7 @@ The user pasted a clipboard image saved at ${relPath}. Use the OCR, vision analy
           try {
             if (!commandCtx.isExposeActive?.()) {
               writeContent(
-                () => renderInfo("COHERE: exposing local inference to mesh...")
+                () => renderInfo("COHERE: exposing current endpoint to mesh...")
               );
               await commandCtx.exposeStart?.("passthrough");
             }
@@ -666225,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,
@@ -668016,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();
@@ -668164,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 {