@mokuyoaxis/dsh-iris 0.3.0-alpha.1 → 0.3.0-beta.1

package/lib/api.js

@@ -13,6 +13,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
+import { pipeline } from 'node:stream/promises';
 import { irisHome, capabilitiesOf, onChange as onConfigChange, providerHealthSnapshot } from './config.js';
 import { mimeOf, mediaUrl } from './media.js';
 import * as tasks from './tasks.js';
@@ -65,7 +66,7 @@ function providerPublic(p) {
     mediaBaseUrl: p.mediaBaseUrl || '',
     enabled: p.enabled !== false,
     ...selectMediaProtocol(p),
-    apiKeyHint: p.dshProvider ? '由 DSH 管理' : keyHint(p.apiKey),
+    apiKeyHint: p.dshProvider ? '由 DSH 管理' : p.apiKeyEnv ? '由环境变量提供' : keyHint(p.apiKey),
     ...(p.dshProvider ? { dshProvider: p.dshProvider } : {}),
     capabilities: capabilitiesOf(p),
     // 迁移/推断结果是否与原始声明不同（UI 提示旧配置已推断）
@@ -445,19 +446,22 @@ function handleWorkbenchPost(req, res, execute, download = false, core) {
 
 async function serveCoreArtifactMedia(artifactId, method, res, core) {
   try {
-    const result = await core.readCoreArtifactMediaForDsh(artifactId);
-    if (res.writableEnded || res.destroyed) return;
-    res.writeHead(200, {
-      'Content-Type': result.artifact.mediaType,
-      'Content-Length': result.bytes.length,
-      'Content-Disposition': 'inline',
-      'Cache-Control': 'private, max-age=3600',
-      'X-Content-Type-Options': 'nosniff',
-      'Cross-Origin-Resource-Policy': 'same-origin',
-      'Referrer-Policy': 'no-referrer'
-    });
-    res.end(method === 'HEAD' ? undefined : result.bytes);
+    await core.streamCoreArtifactMediaForDsh(artifactId, async result => {
+      if (res.writableEnded || res.destroyed) return;
+      res.writeHead(200, {
+        'Content-Type': result.artifact.mediaType,
+        'Content-Length': result.artifact.size,
+        'Content-Disposition': 'inline',
+        'Cache-Control': 'private, max-age=3600',
+        'X-Content-Type-Options': 'nosniff',
+        'Cross-Origin-Resource-Policy': 'same-origin',
+        'Referrer-Policy': 'no-referrer'
+      });
+      if (method === 'HEAD') res.end();
+      else await pipeline(result.stream, res);
+    }, { headOnly: method === 'HEAD' });
   } catch (_) {
+    if (res.headersSent || res.destroyed) { res.destroy(); return; }
     return sendJson(res, 404, { error: 'not found' });
   }
 }
@@ -567,10 +571,16 @@ function handleCoreTaskRetry(taskId, req, res, core) {
         error.statusCode = 400;
         throw error;
       }
+      if (body.video_mode !== undefined && ['img_data_url', 'first_frame_path', 'audio_path'].some(field => Object.hasOwn(body, field))) {
+        throw Object.assign(new Error('DSH 视频重试仅提供明确的文生入口；图生/数字人视频请通过视频工具或 CLI 重新提供首帧和音频'), {
+          code: 'IRIS_COMMAND_INPUT_INVALID'
+        });
+      }
       const prompt = String(body.prompt || '');
       const result = await core.retryProviderTaskForDsh({
         taskId,
         prompt,
+        ...(body.video_mode !== undefined ? { videoMode: body.video_mode } : {}),
         ...(body.source_artifact_id !== undefined ? { sourceArtifactId: body.source_artifact_id } : {}),
         ...(body.text !== undefined ? { text: String(body.text) } : {}),
         ...(body.voice !== undefined ? { voice: String(body.voice) } : {}),

package/lib/application-runtime.js

@@ -10,6 +10,9 @@ import { createLocalCreationService } from './local-creation.js';
 import { createLocalOperationService } from './local-operations.js';
 import { reservePluginOperation } from './plugin-operations.js';
 import { invokeReservedPlugin } from './plugin-execution.js';
+import { AsyncResource } from 'node:async_hooks';
+import { createApplicationWriter } from './application-writer.js';
+import { createMediaScheduler } from './media-scheduler.js';
 
 // Internal first-slice execution surface, not a public API or an HTTP allowlist.
 const COMMAND_MODES = Object.freeze({
@@ -19,7 +22,7 @@ const COMMAND_MODES = Object.freeze({
   'flow.init': 'writer', 'flow.create': 'writer', 'flow.continue': 'writer', 'flow.select': 'writer', 'flow.export': 'writer',
   'flow.inspect': 'reader', 'flow.list': 'reader',
   'creation.init': 'writer', 'creation.image': 'writer', 'creation.flow': 'writer', 'creation.generate': 'writer',
-  'creation.audio': 'writer', 'creation.speech': 'writer', 'creation.transcribe': 'writer',
+  'creation.audio': 'writer', 'creation.speech': 'writer', 'creation.transcribe': 'writer', 'creation.video': 'writer',
   'creation.root': 'reader', 'creation.lookup': 'reader',
   'execution.init': 'writer', 'operation.accept': 'writer', 'operation.transition': 'writer',
   'operation.inspect': 'reader', 'operation.lookup': 'reader', 'operation.list': 'reader'
@@ -38,7 +41,8 @@ function closed() {
 }
 
 /** Instance-owned FIFO and operation-scoped Core leases. No I/O until an explicit operation. */
-export function createApplicationRuntime({ dataRoot, resolveImageCandidates, resolveAudioCandidates, resolveTaskAdapter } = {}) {
+export function createApplicationRuntime({ dataRoot, resolveImageCandidates, resolveAudioCandidates, resolveVideoCandidates, resolveTaskAdapter,
+  scheduling, scheduler: suppliedScheduler } = {}) {
   const root = normalizeCoreOptions({ dataRoot }).dataRoot;
   if (resolveImageCandidates !== undefined && typeof resolveImageCandidates !== 'function') {
     throw new TypeError('resolveImageCandidates 必须是显式候选解析函数');
@@ -47,22 +51,29 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     throw new TypeError('resolveTaskAdapter 必须是显式 Task Provider 解析函数');
   }
   if (resolveAudioCandidates !== undefined && typeof resolveAudioCandidates !== 'function') throw new TypeError('音频候选解析须为函数');
+  if (resolveVideoCandidates !== undefined && typeof resolveVideoCandidates !== 'function') throw new TypeError('视频候选解析须为函数');
   let state = 'open';
   const queue = [];
   const active = new Set();
   let writer = null;
   let disposePromise;
   let cleanupFailure;
+  const scheduler = suppliedScheduler || (scheduling ? createMediaScheduler(scheduling) : undefined);
+  const managedJobs = new Set();
+  const cooperative = scheduler ? createApplicationWriter({ dataRoot: root, policy: scheduler.policy, scheduler,
+    onFailure(error) { cleanupFailure ||= error; state = 'closing'; cooperative.abort(); stopAll(); } }) : undefined;
 
   function snapshot() {
     return Object.freeze({ state, queuedWrites: queue.length, activeWrites: Number(Boolean(writer)),
-      activeReaders: active.size - Number(Boolean(writer)), cleanupFailed: Boolean(cleanupFailure) });
+      activeReaders: active.size - Number(Boolean(writer)), cleanupFailed: Boolean(cleanupFailure),
+      ...(cooperative ? { ...cooperative.snapshot(), schedulingEnabled: true } : {}) });
   }
 
   function detach(job) { job.signal?.removeEventListener('abort', job.onAbort); }
 
   function rejectQueued(job, error) {
     detach(job);
+    job.resource.emitDestroy();
     job.reject(error);
   }
 
@@ -114,7 +125,7 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
 
   function start(job) {
     active.add(job);
-    job.done = Promise.resolve().then(async () => {
+    job.done = job.resource.runInAsyncScope(() => Promise.resolve().then(async () => {
       let result, error, failed = false;
       try { result = await perform(job); }
       catch (caught) { failed = true; error = caught; }
@@ -122,8 +133,9 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
       active.delete(job);
       if (writer === job) writer = null;
       if (failed) job.reject(error); else job.resolve(result);
+      job.resource.emitDestroy();
       dispatch();
-    });
+    }));
   }
 
   function dispatch() {
@@ -132,12 +144,19 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     start(writer);
   }
 
-  function schedule(mode, action, { signal } = {}) {
+  function schedule(mode, action, { signal, managed = false, transaction = false, finalize = false, key } = {}) {
     if (signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError('signal 必须是 AbortSignal');
     if (state !== 'open') return Promise.reject(closed());
     if (signal?.aborted) return Promise.reject(aborted());
+    if (mode === 'writer' && cooperative) {
+      const promise = cooperative.execute(action, { signal, managed: managed || transaction, transaction, finalize, key });
+      managedJobs.add(promise);
+      void promise.then(() => managedJobs.delete(promise), () => managedJobs.delete(promise));
+      return promise;
+    }
     let job;
-    const result = new Promise((resolve, reject) => { job = { mode, action, signal, resolve, reject, aborted: false }; });
+    const result = new Promise((resolve, reject) => { job = { mode, action, signal, resolve, reject, aborted: false,
+      resource: new AsyncResource('IrisApplicationJob') }; });
     job.onAbort = () => {
       const index = queue.indexOf(job);
       if (index >= 0) { queue.splice(index, 1); rejectQueued(job, aborted()); }
@@ -163,16 +182,19 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     const ownedInput = structuredClone(input);
     return schedule(COMMAND_MODES[name], runtime => {
       const ports = resolveTaskAdapter ? { resolveTaskAdapter: async task => {
-        const adapter = await resolveTaskAdapter(task, { signal: runtime.signal });
+        const resolve = () => resolveTaskAdapter(task, { signal: runtime.signal });
+        const adapter = await (runtime.networkWait ? runtime.networkWait(resolve, 'candidates') : resolve());
         if (runtime.signal.aborted) throw aborted();
         return adapter;
       } } : {};
       if (name === 'execution.init' || name.startsWith('operation.')) return createLocalOperationService(runtime).execute(name, ownedInput);
-      if (name.startsWith('creation.')) return createLocalCreationService(runtime, { resolveImageCandidates, resolveAudioCandidates,
+      if (name.startsWith('creation.')) return createLocalCreationService(runtime, { resolveImageCandidates, resolveAudioCandidates, resolveVideoCandidates,
         onPrepared: options?.onPrepared }).execute(name, ownedInput);
-      if (name.startsWith('flow.')) return createImageFlowService(runtime, { ...ports, resolveImageCandidates, resolveAudioCandidates }).execute(name, ownedInput);
+      if (name.startsWith('flow.')) return createImageFlowService(runtime, { ...ports, resolveImageCandidates, resolveAudioCandidates, resolveVideoCandidates }).execute(name, ownedInput);
       return createCommandService(runtime, ports).execute(name, ownedInput);
-    }, options);
+    }, { ...options, managed: true,
+      key: ownedInput?.run_id ? `run:${ownedInput.run_id}` : ownedInput?.task_id ? `task:${ownedInput.task_id}`
+        : name.startsWith('creation.') && ownedInput?.key ? `creation:${name}:${ownedInput.key}` : undefined });
   }
 
   async function generateImage(input, options) {
@@ -181,11 +203,12 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
       throw new ApplicationRuntimeError('IRIS_APP_IMAGE_RESOLVER_MISSING', '图片生成需要显式提供候选解析函数');
     }
     return schedule('writer', async runtime => {
-      const candidates = await resolveImageCandidates({ modelRef: normalized.modelRef, signal: runtime.signal });
+      const resolve = () => resolveImageCandidates({ modelRef: normalized.modelRef, signal: runtime.signal });
+      const candidates = await (runtime.networkWait ? runtime.networkWait(resolve, 'candidates') : resolve());
       if (runtime.signal.aborted) throw aborted();
       return createProviderTaskRunner(runtime).submit({ capability: 'image', candidates,
         providerInput: normalized.providerInput, sourceArtifactId: normalized.sourceArtifactId });
-    }, options);
+    }, { ...options, managed: true });
   }
 
   /** Explicit trusted assembly only. No HTTP/MCP route or persistent Operation action is added. */
@@ -201,7 +224,10 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     if (disposePromise) return disposePromise;
     state = 'closing';
     stopAll();
-    disposePromise = Promise.all([...active].map(job => job.done)).then(() => {
+    cooperative?.abort();
+    disposePromise = Promise.allSettled([...active].map(job => job.done).concat([...managedJobs])).then(async () => {
+      await cooperative?.dispose();
+      if (!suppliedScheduler) scheduler?.dispose();
       if (cleanupFailure) throw cleanupFailure;
       state = 'closed';
       return snapshot();
@@ -209,5 +235,8 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     return disposePromise;
   }
 
-  return Object.freeze({ execute, generateImage, executePluginOperation, run, dispose, snapshot });
+  return Object.freeze({ execute, generateImage, executePluginOperation, run, dispose, snapshot, scheduler,
+    schedulingPhase(key) { return cooperative?.phase(key) || null; },
+    runMedia(action, options) { return schedule('writer', action, { ...options, managed: true }); },
+    transaction(action, { finalize = false } = {}) { return schedule('writer', action, { transaction: true, finalize }); } });
 }

package/lib/application-writer.js

@@ -0,0 +1,193 @@
+import { AsyncResource } from 'node:async_hooks';
+import { createCoreRuntime } from './core-runtime.js';
+import { schedulingError } from './scheduling-policy.js';
+import { performance } from 'node:perf_hooks';
+
+const aborted = () => Object.assign(schedulingError('IRIS_APP_ABORTED', 'Iris 操作已取消'), { name: 'AbortError' });
+const closed = () => schedulingError('IRIS_APP_CLOSED', 'Iris 应用运行时正在关闭或已关闭');
+
+/** Internal cooperative writer. Only known media code may loan its write turn. */
+export function createApplicationWriter({ dataRoot, policy, scheduler, onFailure }) {
+  const pending = [], active = new Set(), taskGate = {};
+  let rootRuntime, owner, closing = false, failure, retiring, disposal;
+  const snapshot = () => ({ queuedWrites: pending.filter(entry => entry.kind === 'start').length,
+    activeWrites: Number(Boolean(rootRuntime)), writeTurn: Number(Boolean(owner)),
+    managedWrites: active.size, waitingWrites: [...active].filter(job => job.parked).length, cleanupFailed: Boolean(failure) });
+
+  function remove(entry) {
+    const index = pending.indexOf(entry);
+    if (index >= 0) pending.splice(index, 1);
+    clearTimeout(entry.timer); entry.signal?.removeEventListener('abort', entry.abort);
+  }
+  function enqueue(entry) {
+    return new Promise((resolve, reject) => {
+      entry.resolve = resolve; entry.reject = reject;
+      pending.push(entry); pump();
+    });
+  }
+  async function retire() {
+    const runtime = rootRuntime;
+    try { await runtime.dispose(); }
+    catch (error) {
+      failure = error; closing = true; onFailure?.(error);
+      for (const entry of [...pending]) { remove(entry); entry.reject(error); }
+      throw error;
+    } finally { rootRuntime = null; retiring = null; pump(); }
+  }
+  function pump() {
+    if (owner || retiring) return;
+    // A waiting exclusive callback cannot block the resumes that let earlier media jobs finish.
+    let index = pending.findIndex(entry => entry.kind !== 'start' || entry.transaction);
+    if (index < 0) index = 0;
+    let entry = pending[index];
+    if (!entry) {
+      if (rootRuntime && !active.size) {
+        retiring = Promise.resolve().then(retire); void retiring.catch(() => {});
+      }
+      return;
+    }
+    if (entry.kind === 'start' && performance.now() >= entry.deadline) {
+      remove(entry); entry.reject(schedulingError('IRIS_SCHEDULER_QUEUE_TIMEOUT', '本地写入等候超时；未开始本次操作')); pump(); return;
+    }
+    if (entry.kind === 'start' && (!entry.managed && active.size || [...active].some(job => !job.managed))) return;
+    remove(entry);
+    if (entry.kind === 'start') {
+      try {
+        if (!rootRuntime) { rootRuntime = createCoreRuntime({ dataRoot, mode: 'writer' }); rootRuntime.start(); }
+      } catch (error) {
+        entry.reject(error);
+        // start may have retained a failed lease; dispose must report that failure.
+        retiring = Promise.resolve().then(retire); void retiring.catch(() => {}); return;
+      }
+      const job = entry.job;
+      active.add(job); owner = job;
+      entry.resolve();
+    } else { owner = entry.job; entry.resolve(); }
+  }
+  function release(job) {
+    if (owner !== job) throw new Error('Iris writer turn ownership mismatch');
+    owner = null;
+    let error;
+    try { scheduler?.changed(dataRoot); } catch (caught) { error = caught; }
+    pump(); return error;
+  }
+  async function networkWait(job, action, reason = 'network') {
+    if (!job.managed || job.parked) throw new Error('Iris write turn can only be loaned once by managed media');
+    job.parked = reason; const releaseError = release(job);
+    let result, error;
+    try { if (releaseError) throw releaseError; result = await action(); } catch (caught) { error = caught; }
+    // Even an aborted operation reacquires its turn before recording acceptance/terminal facts.
+    await enqueue({ kind: 'resume', job }); job.parked = null; job.phase = null;
+    if (error) throw error;
+    return result;
+  }
+  async function checkpoint(job, action) {
+    if (job.finished) throw closed();
+    const parked = job.parked;
+    if (parked) await enqueue({ kind: 'checkpoint', job });
+    if (owner !== job) throw new Error('Core checkpoint requires the current write turn');
+    try {
+      const value = action();
+      if (value && typeof value.then === 'function') throw new TypeError('Core checkpoint 必须同步完成');
+      return value;
+    } finally { if (parked) { const error = release(job); if (error) throw error; } }
+  }
+  async function execute(action, { signal, managed = false, transaction = false, finalize = false, key } = {}) {
+    if (closing) throw closed();
+    signal?.throwIfAborted();
+    if (!finalize && active.size + pending.filter(entry => entry.kind === 'start').length >= policy.queueLimit) {
+      throw schedulingError('IRIS_SCHEDULER_QUEUE_FULL', '本地写入队列已满；请查询原操作后再明确重试');
+    }
+    const resource = new AsyncResource('IrisApplicationWriter'), controller = new AbortController();
+    const job = { managed, parked: null, key, controller, cleanup: [], inFlight: new Set(), finished: false };
+    // Only the runner uses finalize for short terminal writes of already accepted Operations.
+    // They must drain under the writer even when new work has reached its admission budget.
+    const entry = { kind: 'start', job, signal, managed, transaction, deadline: finalize ? Infinity : performance.now() + policy.queueTimeoutMs };
+    // Same durable Run/creation key must not overlap even if its candidate resolver waits.
+    if (key && ([...active].some(other => other.key === key) || pending.some(other => other.job.key === key))) {
+      resource.emitDestroy(); throw schedulingError('IRIS_APP_OPERATION_BUSY', '原 Run 或创建 Key 正在执行；请查询原操作');
+    }
+    entry.abort = () => {
+      controller.abort();
+      if (!active.has(job)) { remove(entry); entry.reject(aborted()); pump(); }
+    };
+    signal?.addEventListener('abort', entry.abort, { once: true });
+    const start = enqueue(entry);
+    // Queued starts are bounded; resumes/terminal persistence never expire behind this timer.
+    if (pending.includes(entry) && !finalize) entry.timer = setTimeout(() => {
+      remove(entry); entry.reject(schedulingError('IRIS_SCHEDULER_QUEUE_TIMEOUT', '本地写入等候超时；未开始本次操作')); pump();
+    }, Math.max(1, entry.deadline - performance.now()));
+    let result, operationError;
+    try {
+      await start;
+      // The queue entry's abort listener was removed at admission; active jobs keep their own signal.
+      signal?.addEventListener('abort', entry.abort, { once: true });
+      if (signal?.aborted) controller.abort();
+      controller.signal.throwIfAborted();
+      const runtime = Object.freeze({
+        get signal() { return controller.signal; }, taskGate,
+        run(operation, callback) {
+          if (job.finished) throw closed();
+          if (owner !== job) throw new Error('Core operation requires the current write turn');
+          const promise = rootRuntime.run(operation, context => callback(Object.freeze({ ...context, signal: controller.signal })));
+          job.inFlight.add(promise);
+          void promise.then(() => job.inFlight.delete(promise), () => job.inFlight.delete(promise));
+          return promise;
+        },
+        snapshot: () => rootRuntime.snapshot(),
+        onDispose(callback) {
+          if (job.finished) throw closed();
+          if (typeof callback !== 'function') throw new TypeError('Core cleanup 必须是函数');
+          job.cleanup.push(callback); return () => { const i = job.cleanup.indexOf(callback); if (i < 0) return false; job.cleanup.splice(i, 1); return true; };
+        },
+        networkWait: (callback, reason) => networkWait(job, callback, reason),
+        checkpoint: callback => checkpoint(job, callback),
+        reportScheduling(phase) { if (job.parked) job.phase = phase; },
+        scheduler,
+        schedulingState: () => job.parked || 'writing'
+      });
+      result = await resource.runInAsyncScope(action, undefined, runtime);
+    } catch (error) { operationError = error; }
+    finally {
+      signal?.removeEventListener('abort', entry.abort);
+      if (active.has(job)) {
+        while (job.inFlight.size) await Promise.allSettled([...job.inFlight]);
+        job.finished = true; controller.abort();
+        try { for (const callback of job.cleanup.reverse()) await callback(); }
+        catch (error) {
+          failure = error; closing = true;
+          // A failed per-job cleanup keeps the same retained-lease semantics as CoreRuntime.
+          rootRuntime.onDispose(() => { throw error; });
+          onFailure?.(error); operationError ||= error;
+        }
+        active.delete(job);
+        if (owner === job) { const error = release(job); operationError ||= error; } else pump();
+        if (retiring) {
+          try { await retiring; }
+          catch (error) { operationError = operationError ? Object.assign(new AggregateError([operationError, error], '操作和写者释放均失败'), { code: error.code }) : error; }
+        }
+      }
+      resource.emitDestroy();
+    }
+    if (operationError) throw operationError;
+    return result;
+  }
+  function dispose() {
+    if (disposal) return disposal;
+    closing = true;
+    for (const entry of [...pending]) if (entry.kind === 'start') { remove(entry); entry.reject(closed()); }
+    for (const job of active) job.controller.abort();
+    disposal = (async () => {
+      // The application awaits admitted jobs before invoking this final drain.
+      if (active.size) throw new Error('Iris writer disposed before jobs drained');
+      pump(); if (retiring) await retiring;
+      if (failure) throw failure;
+    })();
+    return disposal;
+  }
+  return Object.freeze({ execute, snapshot, dispose, phase(key) { const job = [...active].find(job => job.key === key); return job?.phase || job?.parked || null; }, abort() {
+    closing = true;
+    for (const entry of [...pending]) if (entry.kind === 'start') { remove(entry); entry.reject(closed()); }
+    for (const job of active) job.controller.abort();
+  } });
+}

package/lib/client.d.ts

@@ -1,5 +1,5 @@
-declare const _default: {
+/** The factory registered with DSH's browser ModuleLoader, not a Node module export. */
+export interface DshClientPlugin {
   inject: string[];
   apply(ctx: any): void;
-};
-export = _default;
+}

package/lib/client.js

@@ -21,7 +21,7 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
   var exports = module.exports;
 
   var React = require('react');
-  var IRIS_CLIENT_VERSION = '0.3.0-alpha.1';
+  var IRIS_CLIENT_VERSION = '0.3.0-beta.1';
   var HOST_CLIENT_PROTOCOL_VERSION = 0;
   var reportedSeats = [];
 
@@ -567,6 +567,7 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
             for (var i = 0; i < sharedListeners.length; i++) {
               sharedListeners[i](data);
             }
+            window.dispatchEvent(new CustomEvent('iris-core-refresh-tick'));
           }
           function load() {
             fetch('/iris/api/state')
@@ -574,7 +575,6 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
               .then(function (data) {
                 if (data) {
                   apply(data);
-                  window.dispatchEvent(new CustomEvent('iris-core-refresh-tick'));
                 }
               })
               .catch(function () { /* 网络抖动静默 */ });
@@ -1623,9 +1623,9 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
             p.protocolInferred ? React.createElement('div', { className: 'iris-pm-note' }, '协议为推断值，请确认') : null,
             p.mediaProtocol === 'comfyui' ? React.createElement('details', {}, React.createElement('summary', {}, '连接设置'),
               React.createElement('div', { className: 'iris-pm-note' }, '服务地址：' + (p.mediaBaseUrl || p.baseUrl)),
-              React.createElement(ProviderEndpointEditor, { provider: p, onNote: setNote, onDone: refresh }),
+              !p.dshProvider ? React.createElement(ProviderEndpointEditor, { provider: p, onNote: setNote, onDone: refresh }) : null,
               !p.dshProvider ? React.createElement(ProviderAuthenticationEditor, { provider: p, onDone: refresh }) : null)
-              : React.createElement(React.Fragment, {}, React.createElement(ProviderEndpointEditor, { provider: p, onNote: setNote, onDone: refresh }),
+              : React.createElement(React.Fragment, {}, !p.dshProvider ? React.createElement(ProviderEndpointEditor, { provider: p, onNote: setNote, onDone: refresh }) : null,
                 !p.dshProvider ? React.createElement(ProviderAuthenticationEditor, { provider: p, onDone: refresh }) : null,
                 React.createElement(VisionInputEditor, { provider: p, onNote: setNote, onDone: refresh })),
             React.createElement('div', { className: 'iris-pm-field' }, React.createElement('label', {}, '媒体协议'), React.createElement('select', { value: p.protocolInferred ? 'auto' : (p.mediaProtocol || 'auto'), onChange: function (e) { setProtocol(p, e.target.value); } },
@@ -2676,8 +2676,11 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
           .then(function (value) {
             if (request.current !== controller || controller.signal.aborted) return;
             setData(value);
-            setNote(value.coreError ? 'Core 作品暂时不可用，当前计数仅含可读取作品。'
-              : value.droppedCore ? '已跳过 ' + value.droppedCore + ' 条不可读取的 Core 作品。' : '');
+            var notes = [];
+            if (value.coreError) notes.push('Core 作品暂时不可用，当前计数仅含可读取作品。');
+            if (value.droppedCore) notes.push('已跳过 ' + value.droppedCore + ' 条损坏、缺失或不支持格式的 Core 作品。');
+            if (value.legacyCoreSkipped) notes.push(value.legacyCoreSkipped + ' 条早期 Core 作品尚未编入当前目录；可按 ID 读取，或显式重建索引后显示。');
+            setNote(notes.join(' '));
           })
           .catch(function (error) { if (request.current === controller && !controller.signal.aborted) setNote(error.message); })
           .finally(function () { if (request.current === controller) { request.current = null; setBusy(false); } });
@@ -2868,33 +2871,46 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
     var EMPTY_CORE_USER = Object.freeze({ rows: [], available: false, degraded: false, droppedTasks: 0 });
 
     function useCoreUserTasks() {
-      var pair = React.useState(EMPTY_CORE_USER);
+      var store = useCoreUserTasks.shared;
+      if (!store) store = useCoreUserTasks.shared = { data: EMPTY_CORE_USER, listeners: [], sequence: 0, refresh: null };
+      var pair = React.useState(store.data);
       var setData = pair[1];
       React.useEffect(function () {
-        var alive = true, sequence = 0;
+        function listener(data) { setData(data); }
+        store.listeners.push(listener);
+        setData(store.data);
         function load() {
-          var current = ++sequence;
+          var current = ++store.sequence;
           fetch('/iris/api/core/snapshot?limit=200')
             .then(function (res) { return res.ok ? res.json() : null; })
             .then(function (data) {
-              if (!alive || current !== sequence || !data || !Array.isArray(data.userTasks)) return;
-              setData({
+              if (!store.listeners.length || current !== store.sequence || !data || !Array.isArray(data.userTasks)) return;
+              store.data = {
                 rows: data.userTasks,
+                activity: data.activity,
                 available: !!data.available,
                 degraded: !!data.degraded,
                 droppedTasks: Number(data.droppedTasks || 0)
-              });
+              };
+              store.listeners.forEach(function (notify) { notify(store.data); });
             })
             .catch(function () { /* Core 不可用不阻塞 legacy 任务区 */ });
         }
-        function changed() { load(); }
-        load();
-        window.addEventListener('iris-core-artifacts-changed', changed);
-        window.addEventListener('iris-core-refresh-tick', changed);
+        if (store.listeners.length === 1) {
+          store.refresh = load;
+          load();
+          window.addEventListener('iris-core-artifacts-changed', load);
+          window.addEventListener('iris-core-refresh-tick', load);
+        }
         return function () {
-          alive = false;
-          window.removeEventListener('iris-core-artifacts-changed', changed);
-          window.removeEventListener('iris-core-refresh-tick', changed);
+          var index = store.listeners.indexOf(listener);
+          if (index >= 0) store.listeners.splice(index, 1);
+          if (!store.listeners.length) {
+            store.sequence++;
+            window.removeEventListener('iris-core-artifacts-changed', store.refresh);
+            window.removeEventListener('iris-core-refresh-tick', store.refresh);
+            store.refresh = null; store.data = EMPTY_CORE_USER;
+          }
         };
       }, []);
       return pair[0];
@@ -3018,11 +3034,16 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
       if (!props.row || props.row.retryable !== true) return null;
       return React.createElement(CoreTaskManualButton, {
         id: props.row.id, action: 'retry',
-        idleLabel: '重试为新任务', busyLabel: '创建中…', failPrefix: '重试',
+        idleLabel: props.row.capability === 'video' ? '重新创建文生视频' : '重试为新任务', busyLabel: '创建中…', failPrefix: '重试',
         title: '创建一个新任务重新生成，可能产生重复费用；生成指令需要重新输入',
         confirm: '将创建一个新任务并可能产生重复生成费用，确定继续？',
         createdPrefix: '已创建新任务：',
         buildBody: function () {
+          var videoMode;
+          if (props.row.capability === 'video') {
+            videoMode = window.prompt('旧视频 Task 不保存模式、首帧和音频。本按钮仅创建新的文生视频；图生视频或数字人视频请取消，并通过视频工具或 CLI 重新提供首帧/音频。\n如明确选择文生视频，请输入 t2v：');
+            if (videoMode === null || String(videoMode).trim() !== 't2v') return null;
+          }
           var isTts = props.row.capability === 'tts';
           var isTranscribe = props.row.capability === 'transcribe';
           var draft = window.prompt(isTts
@@ -3040,7 +3061,8 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
             }
             return isTts ? { text: draft, confirmBilling: true }
             : isTranscribe ? { audio_url: draft, confirmBilling: true }
-            : { prompt: draft, confirmBilling: true, ...(sourceArtifactId ? { source_artifact_id: String(sourceArtifactId).trim() } : {}) };
+            : { prompt: draft, confirmBilling: true, ...(videoMode ? { video_mode: 't2v' } : {}),
+              ...(sourceArtifactId ? { source_artifact_id: String(sourceArtifactId).trim() } : {}) };
         }
       });
     }
@@ -4245,13 +4267,21 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
     function ProgressDock() {
       var state = useIrisState(5000);
       var running = (state && state.tasks && state.tasks.running) || [];
-      if (!running.length) return null;
+      var coreUser = useCoreUserTasks();
+      var coreRows = coreUser.activity && coreUser.activity.recent || [];
+      if (!running.length && !coreRows.length) return null;
       return React.createElement('div', { className: 'iris-progress-dock' },
         running.map(function (t) {
           return React.createElement('div', { key: t.id, className: 'iris-progress-row' },
             React.createElement('span', {}, '🫧 ' + t.cap),
             React.createElement('span', {}, t.model || ''),
             React.createElement('span', {}, String(t.progress || '')));
+        }),
+        coreRows.map(function (row) {
+          return React.createElement('div', { key: 'core:' + row.id, className: 'iris-progress-row' },
+            React.createElement('span', {}, 'Core · ' + row.capability),
+            React.createElement('span', {}, row.model),
+            React.createElement('span', {}, row.label));
         }));
     }
 
@@ -4280,6 +4310,8 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
 
     function FloatingBubble() {
       var state = useIrisState(5000);
+      var coreUser = useCoreUserTasks();
+      var activity = coreUser.activity;
       var providers = (state && state.providers) || [];
       var fallbackConfigured = providers.some(function (p) { return p.enabled && p.apiKeyHint; });
       var overallState = state && state.health && HEALTH_META[state.health.overall]
@@ -4386,9 +4418,14 @@ window.__ModuleLoader__.load({ id: '@mokuyoaxis/dsh-iris', factory: (require) =>
         style = { right: DEFAULT_X + 'px', bottom: DEFAULT_Y + 'px' };
       }
 
-      var badgeCount = running.length + attention.length;
-      var badge = badgeCount
-        ? React.createElement('span', { className: 'iris-bubble-badge', title: attention.length ? attention.length + ' 个任务需要处理' : '' }, badgeCount)
+      var coreCount = activity ? activity.running + activity.paused + activity.attention : 0;
+      var badgeCount = running.length + attention.length + coreCount;
+      var badgeTitle = '旧任务：' + running.length + ' 运行中，' + attention.length + ' 待处理';
+      if (activity) badgeTitle += '；Core：' + activity.running + ' 运行中，' + activity.paused + ' 观察暂停，' + activity.attention + ' 待处理'
+        + (activity.truncated ? '（部分较早的 Core 记录尚未统计）' : '');
+      var badge = badgeCount || activity && activity.truncated
+        ? React.createElement('span', { className: 'iris-bubble-badge', title: badgeTitle, 'aria-label': badgeTitle },
+          badgeCount ? String(badgeCount) + (activity && activity.truncated ? '+' : '') : '…')
         : null;
 
       var panel = null;

package/lib/comfyui-adapter.js

@@ -6,6 +6,7 @@ import { parseImageSize } from './provider-protocol.js';
 import { createComfyUiClient, comfyFail as fail } from './comfyui-client.js';
 import { inspectComfyWorkflow } from './comfyui-inspection.js';
 import { writePrivateFile } from './private-storage.js';
+import { inheritedProviderFetch } from './provider-network.js';
 
 const TASK = /^[A-Za-z0-9_-]{1,200}$/;
 function imageLocation(value) {
@@ -16,8 +17,8 @@ function imageLocation(value) {
   }
   return { filename: value.filename, subfolder: value.subfolder, type: value.type };
 }
-export function createComfyUiProviderAdapter(provider, { fetchPort = globalThis.fetch } = {}) {
-  const client = createComfyUiClient(provider, { fetchPort }), { route, request } = client;
+export function createComfyUiProviderAdapter(provider, { fetchPort = inheritedProviderFetch, network } = {}) {
+  const client = createComfyUiClient(provider, { fetchPort, network }), { route, request } = client;
   function workflow(model) {
     const value = model ? provider.models?.find(entry => entry.id === model)?.comfyWorkflow : provider.comfyWorkflow;
     try { return checkedComfyWorkflow(value); }