@mokuyoaxis/dsh-iris 0.1.4 → 0.2.0

package/lib/actions.js

@@ -20,17 +20,20 @@ import * as artifacts from './artifacts.js';
 import { registerMedia, mediaLinksOf, webBase } from './media.js';
 import { buildVisionBackendsFromHost, askWithBackends, testVisionCapability, RED_TEST_IMAGE } from './vision.js';
 import { HOST_CONTRACT_VERSION, HOST_PORTS, defineHostAdapter, hasHostPort, requireHostPort } from './host-contract.js';
-import { cropImage, pixelDiff, imageDimensions } from './pixels.js';
+import { coreSnapshotForDsh, cropForDsh, diffForDsh, framesForDsh, inspectProviderTaskForDsh, submitProviderTaskForDsh, watchProviderTaskForDsh } from './dsh-core-adapter.js';
+import { imageDimensions } from './pixels.js';
 import { locateObject } from './locate.js';
 import { longOcr } from './ocr.js';
 import { ffmpegAvailable, extractFrames, probeVideo } from './media-probe.js';
 import { buildContactSheet, summarizeMedia } from './summarize.js';
 import { ensurePrivateDir, writePrivateFile } from './private-storage.js';
-import { inferMediaProtocol } from './provider-protocol.js';
+import { selectMediaProtocol } from './provider-protocol.js';
+import { providerTaskBinding } from './provider-catalog.js';
 import { ProviderContractError, submitWithAcceptanceBoundary } from './provider-contract.js';
-import { invokeProviderOperation, providerPollTaskView } from './provider-adapter.js';
+import { invokeProviderOperation, providerPollTaskView, prepareProviderInput } from './provider-adapter.js';
 import { createConfiguredProviderAdapter } from './provider-adapters.js';
 import { deriveUserState } from './task-semantics.js';
+import { normalizeGenerationInput } from './generation-input.js';
 
 const MEDIA_TYPES = {
   '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
@@ -53,6 +56,9 @@ function actionHost(value) {
   throw new TypeError('Iris Action 只接受有效的 Host Adapter，不接受原始 ctx');
 }
 
+// 工作台清空可选文本框会发送空字符串；在 Host 边界解释为未提供，保持默认值。
+function optionalActionText(value) { return value === '' ? undefined : value; }
+
 /* ---------------- 视觉效果自述（辅助 iris_draw_image） ---------------- */
 async function describeFirstImage(host, ref, absPath, originalPrompt) {
   try {
@@ -89,24 +95,43 @@ function throwIfAborted(signal) {
  */
 function selectProviders(capability, label, requestedModelRef) {
   let providers = store.pickAllFor(capability);
-  const parsedRef = models.parseModelRef(String(requestedModelRef || '').trim());
-  if (parsedRef) {
+  const requested = String(requestedModelRef || '').trim();
+  if (requested) {
+    const pool = models.modelPool(store.providers());
+    const selected = models.resolvePoolModel(pool, requested, capability);
     const field = models.CAP_FIELD[capability];
-    providers = providers.filter((p) => p.id === parsedRef.providerId && (!field || p[field] === parsedRef.modelId));
+    providers = selected ? providers.filter((p) => p.id === selected.providerId && p[field] === selected.id) : [];
     if (!providers.length) throw new Error('iris: 指定的模型复合引用不可用或不具备' + label + '能力');
   }
   if (!providers.length) throw new Error('iris: 没有可用' + label + '供应商——先在 Iris 设置里添加、标注并分配模型');
   return providers;
 }
 
+function configuredModel(provider, capability, requested) {
+  const ref = models.resolveModelRef(provider, capability, requested);
+  if (!ref) throw new Error('iris: 未配置可用模型，请发现或手工添加并标注对应能力');
+  return models.parseModelRef(ref).modelId;
+}
+
+function routeSelectionReason(provider, capability, requested) {
+  if (String(requested || '').trim()) return 'explicit';
+  const field = models.CAP_FIELD[capability];
+  const selectedRef = field && provider?.[field]
+    ? models.modelRef(provider.id, provider[field]) : '';
+  return models.selectionReasonForModel(
+    models.modelPool(store.providers()),
+    capability,
+    store.assignments()[capability],
+    selectedRef
+  ) || 'pool';
+}
+
 function imageRoute(provider, args) {
-  const protocol = provider.mediaProtocol || inferMediaProtocol(provider.baseUrl);
-  const parsed = models.parseModelRef(String(args.model || ''));
-  const model = args.model
-    ? (parsed?.modelId || String(args.model))
-    : (provider.imageModel || (protocol === 'openai-images' ? 'gpt-image-1' : 'wan2.2-t2i-flash'));
+  const protocol = selectMediaProtocol(provider).mediaProtocol;
+  const model = configuredModel(provider, cap.CAPABILITIES.IMAGE, args.model);
   return {
     provider, protocol, model, modelRef: models.modelRef(provider.id, model),
+    selectionReason: routeSelectionReason(provider, cap.CAPABILITIES.IMAGE, args.model),
     adapter: createConfiguredProviderAdapter(provider, { protocol })
   };
 }
@@ -184,148 +209,97 @@ async function askWithHealth(backends, request) {
   }
 }
 
-async function deliverCompletedImage(taskId, value, signal, providerAdapter) {
-  const names = [];
-  try {
-    tasks.beginDelivery(taskId);
-    if (value && value.kind === 'urls') {
-      for (const url of value.items || []) {
-        const name = taskId + '-' + names.length + '.' + adapters.extFromUrl(url, 'png');
-        await invokeProviderOperation(providerAdapter, 'download', {
-          artifact: { kind: 'remote-url', url }, targetPath: path.join(outputDir(), name), signal
-        });
-        names.push(name);
-      }
-    } else if (value && value.kind === 'openai') {
-      for (const item of value.items || []) {
-        const name = taskId + '-' + names.length + '.png';
-        const target = path.join(outputDir(), name);
-        if (item && item.b64) writePrivateFile(target, Buffer.from(item.b64, 'base64'));
-        else if (item && item.url) await invokeProviderOperation(providerAdapter, 'download', {
-          artifact: { kind: 'remote-url', url: item.url }, targetPath: target, signal
-        });
-        else throw new Error('同步图片结果缺少 b64 或 URL');
-        names.push(name);
-      }
-    } else {
-      throw new Error('未知同步图片结果结构');
-    }
-    if (!names.length) throw new Error('生成已成功，但没有可交付的图片');
-    for (const name of names) registerMedia(taskId, path.join(outputDir(), name));
-    tasks.completeDelivery(taskId, names);
-    return tasks.get(taskId);
-  } catch (error) {
-    let recorded;
-    try {
-      recorded = tasks.failDelivery(taskId, error, names);
-    } catch (persistError) {
-      throw taskActionError(taskId, '图像已生成，但交付状态无法可靠落盘；禁止重新生成', {
-        message: String((persistError && persistError.message) || persistError)
+function recordCoreTaskAttemptHealth(task, capability) {
+  const label = capability === cap.CAPABILITIES.VIDEO ? '视频' : '图片';
+  for (const attempt of task?.attempts || []) {
+    const parsed = models.parseModelRef(attempt.model);
+    if (!parsed) continue;
+    if (attempt.acceptance === 'accepted') {
+      recordProviderHealthSafe(attempt.providerId, parsed.modelId, capability, {
+        ok: true, category: 'success',
+        note: attempt.resultKind === 'completed' ? `同步${label}生成成功` : `${label}任务已受理`
+      });
+    } else if (attempt.error) {
+      recordProviderHealthSafe(attempt.providerId, parsed.modelId, capability, {
+        ok: false, category: attempt.error.category, httpStatus: attempt.error.httpStatus,
+        note: attempt.error.safeMessage
       });
     }
-    throw taskActionError(taskId, '图像已生成，但产物交付失败：' + recorded.error, recorded.lastError);
   }
 }
 
-/** v0.1.3 图片能力统一链路：异步、同步及混合候选共用一个 Task。 */
-async function submitImageV2(routes, prompt, args, signal) {
-  const task = tasks.createV2({
-    cap: 'image',
-    prompt: prompt.slice(0, 4000),
-    size: args.size || '',
-    count: Number(args.n || 1),
-    ...(args.model ? { requestedModelRef: String(args.model) } : {}),
-    ...(args._retryOf ? { retryOf: String(args._retryOf) } : {})
-  });
-  const candidates = routes.map((route) => ({
-    id: route.provider.id,
-    model: route.modelRef,
-    route,
-    submit: async () => {
-      if (signal && signal.aborted) {
-        throw new ProviderContractError('提交前收到取消信号', {
-          stage: 'submit', category: 'aborted', acceptance: 'unknown'
-        });
-      }
-      return observeProviderCapability(route, cap.CAPABILITIES.IMAGE, () =>
-        invokeProviderOperation(route.adapter, 'submit', {
-          capability: 'image',
-          model: route.model,
-          input: { prompt, size: args.size, n: args.n },
-          signal
-        }));
-    }
-  }));
-
-  const submitted = await submitWithAcceptanceBoundary(candidates, { capability: 'image' }, {
-    beforeAttempt: ({ providerId, model }) => {
-      const route = routes.find((item) => item.provider.id === providerId && item.modelRef === model);
-      if (!route) throw new Error('候选路由与 Attempt 身份不一致');
-      return tasks.beginAttempt(task.id, {
-        providerId,
-        providerName: route.provider.name,
-        model,
-        protocol: route.protocol
-      });
-    },
-    afterResult: (snapshot) => tasks.recordAttemptResult(task.id, snapshot)
+/** DSH 图片入口：同步和异步候选共用一份 Core Task/Attempt/Artifact 事实。 */
+async function submitCoreImage(routes, providerInput, signal) {
+  const submitted = await submitProviderTaskForDsh({
+    capability: 'image',
+    candidates: routes.map((route) => ({
+      adapter: route.adapter,
+      model: route.modelRef,
+      selectionReason: route.selectionReason,
+      providerBinding: providerTaskBinding(route.provider)
+    })),
+    providerInput,
+    signal
   });
-
-  if (submitted.localError) {
-    throw taskActionError(task.id, '提交结果未能可靠落盘，已停止后续候选', submitted.localError);
-  }
-  if (!submitted.candidate) {
-    const lastError = submitted.result && submitted.result.error;
-    tasks.finalizeNoAcceptance(task.id, lastError || '所有候选均明确未受理');
-    throw taskActionError(task.id, '所有候选均明确未受理', submitted.attempts);
+  const task = submitted.task;
+  recordCoreTaskAttemptHealth(task, cap.CAPABILITIES.IMAGE);
+  if (submitted.localError) throw taskActionError(task.id, 'Core 提交结果未能可靠落盘，已停止后续候选', submitted.localError);
+  if (task.acceptance === 'unknown') throw taskActionError(task.id, '供应商受理状态未知，禁止自动重提', task.lastError);
+  if (task.acceptance === 'not_accepted') throw taskActionError(task.id, '所有候选均明确未受理', task.attempts);
+  if (task.outcome === 'succeeded' && task.deliveryState === 'failed') {
+    throw taskActionError(task.id, '图像已生成，但 Core Artifact 交付失败；禁止重新生成', task.lastError);
   }
-  if (submitted.result.kind === 'acceptance_unknown') {
-    const safe = submitted.result.error && submitted.result.error.safeMessage;
-    throw taskActionError(task.id, '供应商受理状态未知，禁止自动重提' + (safe ? '：' + safe : ''), submitted.result.error);
+  const selected = routes.find((route) => route.provider.id === task.providerId && route.modelRef === task.modelRef);
+  if (!selected) throw taskActionError(task.id, 'Core Task 的供应商身份无法映射回当前路由', task);
+  if (task.acceptance === 'accepted' && task.remoteTaskId
+      && ['none', 'unknown'].includes(task.outcome) && task.phase !== 'terminal') {
+    await watchProviderTaskForDsh({ taskId: task.id, signal });
+  } else if (task.outcome !== 'succeeded' || task.deliveryState !== 'ready' || !task.artifactIds.length) {
+    throw taskActionError(task.id, '图片路由没有得到可观察任务或可交付产物；事实已保留在 Core，未回退重提', task);
   }
+  return { task, provider: selected.provider, model: selected.model };
+}
 
-  const route = submitted.candidate.route;
-  if (submitted.result.kind === 'completed') {
-    const delivered = await deliverCompletedImage(task.id, submitted.result.value, signal, route.adapter);
-    return { task: delivered, provider: route.provider, model: route.model, remoteTaskId: null };
-  }
-  if (submitted.result.kind !== 'accepted') {
-    throw taskActionError(task.id, '图片提交结果无法识别，已停止后续候选', submitted.result);
+/**
+ * DSH 视频入口（E 阶段）：t2v/i2v 共用 Core Task/Attempt/Artifact 事实轴，
+ * 不共用图片状态机——视频走自己的交付 Profile（video/mp4 / generated-video）。
+ * s2v 数字人（需先上传首帧与音频到临时存储）仍走 legacy 链路，见 register('video')。
+ */
+async function submitCoreVideo(routes, frame, prompt, args, signal) {
+  const { providerInput } = normalizeGenerationInput('video', {
+    prompt,
+    img_data_url: frame ? fileDataUrl(frame) : undefined,
+    size: optionalActionText(args.size),
+    duration: args.duration
+  });
+  const submitted = await submitProviderTaskForDsh({
+    capability: 'video',
+    candidates: routes.map((route) => ({
+      adapter: route.adapter,
+      model: route.modelRef,
+      selectionReason: route.selectionReason,
+      providerBinding: providerTaskBinding(route.provider)
+    })),
+    providerInput,
+    signal
+  });
+  const task = submitted.task;
+  recordCoreTaskAttemptHealth(task, cap.CAPABILITIES.VIDEO);
+  if (submitted.localError) throw taskActionError(task.id, 'Core 提交结果未能可靠落盘，已停止后续候选', submitted.localError);
+  if (task.acceptance === 'unknown') throw taskActionError(task.id, '供应商受理状态未知，禁止自动重提', task.lastError);
+  if (task.acceptance === 'not_accepted') throw taskActionError(task.id, '所有候选均明确未受理', task.attempts);
+  if (task.outcome === 'succeeded' && task.deliveryState === 'failed') {
+    throw taskActionError(task.id, '视频已生成，但 Core Artifact 交付失败；禁止重新生成', task.lastError);
   }
-
-  try {
-    tasks.activateWatch(task.id);
-  } catch (error) {
-    throw taskActionError(task.id, '远端已受理，但本地盯守状态落盘失败；禁止自动重提', { message: String(error.message || error) });
+  const selected = routes.find((route) => route.provider.id === task.providerId && route.modelRef === task.modelRef);
+  if (!selected) throw taskActionError(task.id, 'Core Task 的供应商身份无法映射回当前路由', task);
+  if (task.acceptance === 'accepted' && task.remoteTaskId
+      && ['none', 'unknown'].includes(task.outcome) && task.phase !== 'terminal') {
+    await watchProviderTaskForDsh({ taskId: task.id, signal });
+  } else if (task.outcome !== 'succeeded' || task.deliveryState !== 'ready' || !task.artifactIds.length) {
+    throw taskActionError(task.id, '视频路由没有得到可观察任务或可交付产物；事实已保留在 Core，未回退重提', task);
   }
-  tasks.watch(tasks.get(task.id), {
-    poll: ({ remoteTaskId, signal: pollSignal }) => observeProviderCapability(
-      route, cap.CAPABILITIES.IMAGE,
-      () => invokeProviderOperation(route.adapter, 'poll', {
-        capability: 'image', remoteTaskId, signal: pollSignal
-      }),
-      { recordSuccess: false }
-    ),
-    intervalMs: 2500,
-    onSuccess: async (record, result) => {
-      const names = [];
-      for (const url of result.urls || []) {
-        const name = record.id + '-' + names.length + '.' + adapters.extFromUrl(url, 'png');
-        await invokeProviderOperation(route.adapter, 'download', {
-          artifact: { kind: 'remote-url', url }, targetPath: path.join(outputDir(), name)
-        });
-        names.push(name);
-      }
-      for (const name of names) registerMedia(record.id, path.join(outputDir(), name));
-      return names;
-    }
-  });
-  return {
-    task: tasks.get(task.id),
-    provider: route.provider,
-    model: route.model,
-    remoteTaskId: submitted.result.remoteTaskId
-  };
+  return { task, provider: selected.provider, model: selected.model, mode: selected.mode };
 }
 
 function findGeneratedAttachment(attachmentId) {
@@ -362,13 +336,19 @@ function fileDataUrl(file) {
 }
 
 function videoRoute(provider, args, frame) {
-  const parsed = models.parseModelRef(String(args.model || ''));
-  const model = args.model ? (parsed?.modelId || String(args.model)) : (provider.videoModel || 'wan2.2-t2v-flash');
-  const isS2V = /s2v/i.test(model);
+  const model = configuredModel(provider, cap.CAPABILITIES.VIDEO, args.model);
+  const protocol = selectMediaProtocol(provider).mediaProtocol;
+  // B-7：必须区分两件事——
+  //   s2vModel  : 该模型【本身】是否是数字人模型（决定它能否接受 audio_path）
+  //   isS2V     : 本次【请求】是否应走 s2v 链路（显式 audio_path 意图 或 模型本身是 s2v）
+  // 旧实现只有 isS2V 且只看模型名，导致 audio_path + 非 s2v 模型被静默降级为 t2v。
+  const s2vModel = /s2v/i.test(model);
+  const isS2V = Boolean(String(args.audio_path || '').trim()) || s2vModel;
   const mode = isS2V ? 's2v' : (frame ? 'i2v' : 't2v');
   return {
-    provider, model, modelRef: models.modelRef(provider.id, model), isS2V, mode, protocol: 'dashscope',
-    adapter: createConfiguredProviderAdapter(provider, { protocol: 'dashscope' })
+    provider, model, modelRef: models.modelRef(provider.id, model), isS2V, s2vModel, mode, protocol,
+    adapter: createConfiguredProviderAdapter(provider, { protocol }),
+    selectionReason: routeSelectionReason(provider, cap.CAPABILITIES.VIDEO, args.model)
   };
 }
 
@@ -405,19 +385,13 @@ async function submitVideoV2(routes, frame, prompt, args, signal) {
         }
         if (!fs.existsSync(audioPath)) throw beforeGenerationError(new Error('iris: 音频文件不存在'), 'validate');
         tasks.markAttemptStage(task.id, attemptId, 'upload');
-        try {
-          const imageUrl = await adapters.uploadTempFile({
-            key: route.provider.apiKey, baseUrl: route.provider.baseUrl,
-            model: route.model, filePath: frame.absPath, signal
-          });
-          const audioUrl = await adapters.uploadTempFile({
-            key: route.provider.apiKey, baseUrl: route.provider.baseUrl,
-            model: route.model, filePath: audioPath, signal
-          });
-          submitArgs = { imgDataUrl: imageUrl, audioUrl, resolution: args.resolution || '480P' };
-        } catch (error) {
-          throw beforeGenerationError(error, 'upload');
-        }
+        const { url: imageUrl } = await prepareProviderInput(route.adapter, {
+          model: route.model, filePath: frame.absPath, signal
+        });
+        const { url: audioUrl } = await prepareProviderInput(route.adapter, {
+          model: route.model, filePath: audioPath, signal
+        });
+        submitArgs = { imgDataUrl: imageUrl, audioUrl, resolution: args.resolution || '480P' };
       } else {
         if (!prompt) throw beforeGenerationError(new Error('iris: 文生/图生视频需要 prompt'), 'validate');
         tasks.markAttemptStage(task.id, attemptId, 'prepare');
@@ -498,147 +472,24 @@ async function submitVideoV2(routes, frame, prompt, args, signal) {
   return { task: tasks.get(task.id), provider: route.provider, model: route.model, remoteTaskId: submitted.result.remoteTaskId };
 }
 
-function simpleModelRoute(provider, args, field, fallback, protocol = 'dashscope') {
-  const parsed = models.parseModelRef(String(args.model || ''));
-  const model = args.model ? (parsed?.modelId || String(args.model)) : (provider[field] || fallback);
+function simpleModelRoute(provider, args, capability) {
+  const protocol = selectMediaProtocol(provider).mediaProtocol;
+  const model = configuredModel(provider, capability, args.model);
   return {
     provider, model, modelRef: models.modelRef(provider.id, model), protocol,
-    adapter: createConfiguredProviderAdapter(provider, { protocol })
+    adapter: createConfiguredProviderAdapter(provider, { protocol }),
+    selectionReason: routeSelectionReason(provider, capability, args.model)
   };
 }
 
-async function submitTranscriptionV2(routes, audioPath, args, signal) {
-  const task = tasks.createV2({
-    cap: 'transcribe', prompt: 'audio transcribe: ' + path.basename(audioPath),
-    ...(args.model ? { requestedModelRef: String(args.model) } : {})
-  });
-  const candidates = routes.map((route) => ({
-    id: route.provider.id,
-    model: route.modelRef,
-    route,
-    submit: async (_input, context) => {
-      tasks.markAttemptStage(task.id, context.attempt.id, 'upload');
-      let audioUrl;
-      try {
-        audioUrl = await adapters.uploadTempFile({
-          key: route.provider.apiKey, baseUrl: route.provider.baseUrl,
-          model: route.model, filePath: audioPath, signal
-        });
-      } catch (error) {
-        throw beforeGenerationError(error, 'upload');
-      }
-      tasks.markAttemptStage(task.id, context.attempt.id, 'submit');
-      return observeProviderCapability(route, cap.CAPABILITIES.TRANSCRIBE, () =>
-        invokeProviderOperation(route.adapter, 'submit', {
-          capability: 'transcribe', model: route.model, input: { audioUrl }, signal
-        }));
-    }
-  }));
-  const submitted = await submitWithAcceptanceBoundary(candidates, { capability: 'transcribe' }, {
-    beforeAttempt: ({ providerId, model }) => {
-      const route = routes.find((item) => item.provider.id === providerId && item.modelRef === model);
-      if (!route) throw new Error('候选路由与 Attempt 身份不一致');
-      return tasks.beginAttempt(task.id, {
-        providerId, providerName: route.provider.name, model, protocol: route.protocol
-      });
-    },
-    afterResult: (snapshot) => tasks.recordAttemptResult(task.id, snapshot)
-  });
-  if (submitted.localError) throw taskActionError(task.id, '转写提交结果未能可靠落盘，已停止后续候选', submitted.localError);
-  if (!submitted.candidate) {
-    tasks.finalizeNoAcceptance(task.id, submitted.result?.error || '所有转写候选均明确未受理');
-    throw taskActionError(task.id, '所有转写候选均明确未受理', submitted.attempts);
-  }
-  if (submitted.result.kind !== 'accepted') {
-    const safe = submitted.result.error && submitted.result.error.safeMessage;
-    throw taskActionError(task.id, '转写受理状态未知，禁止自动重提' + (safe ? '：' + safe : ''), submitted.result.error);
-  }
-  const route = submitted.candidate.route;
-  tasks.activateWatch(task.id);
-  tasks.watch(tasks.get(task.id), {
-    poll: ({ remoteTaskId: id, signal: pollSignal }) => observeProviderCapability(
-      route, cap.CAPABILITIES.TRANSCRIBE,
-      () => invokeProviderOperation(route.adapter, 'poll', {
-        capability: 'transcribe', remoteTaskId: id, signal: pollSignal
-      }),
-      { recordSuccess: false }
-    ),
-    intervalMs: 2500,
-    allowEmptyResult: true,
-    onSuccess: async (record, result) => {
-      tasks.update(record.id, { transcribeText: (result.urls && result.urls.join('')) || '' });
-      return [];
-    }
-  });
-  return { task: tasks.get(task.id), provider: route.provider, model: route.model, remoteTaskId: submitted.result.remoteTaskId };
-}
 
-async function submitTtsV2(routes, text, args, signal) {
-  const task = tasks.createV2({
-    cap: 'tts', prompt: text.slice(0, 500),
-    ...(args.model ? { requestedModelRef: String(args.model) } : {})
-  });
-  const candidates = routes.map((route) => ({
-    id: route.provider.id,
-    model: route.modelRef,
-    route,
-    submit: async (_input, context) => {
-      tasks.markAttemptStage(task.id, context.attempt.id, 'submit');
-      return observeProviderCapability(route, cap.CAPABILITIES.TTS, () =>
-        invokeProviderOperation(route.adapter, 'submit', {
-          capability: 'tts', model: route.model, input: { text, voice: route.voice }, signal
-        }));
-    }
-  }));
-  const submitted = await submitWithAcceptanceBoundary(candidates, { capability: 'tts' }, {
-    beforeAttempt: ({ providerId, model }) => {
-      const route = routes.find((item) => item.provider.id === providerId && item.modelRef === model);
-      if (!route) throw new Error('候选路由与 Attempt 身份不一致');
-      const attempt = tasks.beginAttempt(task.id, {
-        providerId, providerName: route.provider.name, model, protocol: route.protocol
-      });
-      tasks.update(task.id, { voice: route.voice });
-      return attempt;
-    },
-    afterResult: (snapshot) => tasks.recordAttemptResult(task.id, snapshot)
-  });
-  if (submitted.localError) throw taskActionError(task.id, '语音合成结果未能可靠落盘，已停止后续候选', submitted.localError);
-  if (!submitted.candidate) {
-    tasks.finalizeNoAcceptance(task.id, submitted.result?.error || '所有语音候选均明确未受理');
-    throw taskActionError(task.id, '所有语音候选均明确未受理', submitted.attempts);
-  }
-  if (submitted.result.kind !== 'completed') {
-    const safe = submitted.result.error && submitted.result.error.safeMessage;
-    throw taskActionError(task.id, '语音合成受理状态未知，禁止自动重提' + (safe ? '：' + safe : ''), submitted.result.error);
-  }
-  const route = submitted.candidate.route;
-  const audio = submitted.result.value || {};
-  const names = [];
-  try {
-    tasks.beginDelivery(task.id);
-    const name = task.id + '.' + (audio.audioUrl ? adapters.extFromUrl(audio.audioUrl, 'wav') : 'wav');
-    const target = path.join(outputDir(), name);
-    if (audio.audioUrl) await invokeProviderOperation(route.adapter, 'download', {
-      artifact: { kind: 'remote-url', url: audio.audioUrl }, targetPath: target, signal
-    });
-    else if (audio.audioB64) writePrivateFile(target, Buffer.from(audio.audioB64, 'base64'));
-    else throw new Error('语音合成成功响应缺少音频数据');
-    names.push(name);
-    registerMedia(task.id, target);
-    tasks.completeDelivery(task.id, names);
-  } catch (error) {
-    const recorded = tasks.failDelivery(task.id, error, names);
-    throw taskActionError(task.id, '语音已合成，但产物交付失败：' + recorded.error, recorded.lastError);
-  }
-  return { task: tasks.get(task.id), provider: route.provider, model: route.model };
-}
 
 /** 重新观察/交付与启动恢复共享的远端查询和本地落盘依赖。 */
 export function taskPollDeps(provider, task) {
   if (!provider || !task) return null;
   if (!['image', 'video', 'transcribe'].includes(task.cap)) return null;
   const protocol = task.protocol || (task.cap === 'image'
-    ? (provider.mediaProtocol || inferMediaProtocol(provider.baseUrl))
+    ? selectMediaProtocol(provider).mediaProtocol
     : 'dashscope');
   let providerAdapter;
   try {
@@ -725,52 +576,173 @@ export async function runAction(host, name, args, { signal } = {}) {
 
 /* ---------- 🖼️ 画图 ---------- */
 register('image', async (host, args, { signal }) => {
-  const prompt = String(args.prompt || '').trim();
-  if (!prompt) throw new Error('iris: prompt 不能为空');
+  const { providerInput } = normalizeGenerationInput('image', {
+    prompt: args.prompt, size: optionalActionText(args.size), n: args.n
+  });
 
   const imageProviders = selectProviders(cap.CAPABILITIES.IMAGE, '图像', args.model);
   const routes = imageProviders.map((provider) => imageRoute(provider, args));
-  const submitted = await submitImageV2(routes, prompt, args, signal);
+  const submitted = await submitCoreImage(routes, providerInput, signal);
+  const firstArtifactId = submitted.task.artifactIds[0];
+  const ready = submitted.task.outcome === 'succeeded'
+    && submitted.task.deliveryState === 'ready' && Boolean(firstArtifactId);
   return {
-    ok: true, taskId: submitted.task.id, model: submitted.model, providerId: submitted.provider.id,
-    remoteTaskId: submitted.remoteTaskId,
-    text: submitted.remoteTaskId
-      ? '[iris] 图像任务已提交（' + submitted.model + '，task: ' + submitted.task.id + '）'
-      : '[iris] 图像任务已完成（' + submitted.model + '，task: ' + submitted.task.id + '）'
+    ok: true, storage: 'core', taskId: submitted.task.id, model: submitted.model,
+    providerId: submitted.provider.id, remoteTaskId: submitted.task.remoteTaskId || null,
+    artifactIds: submitted.task.artifactIds,
+    ...(ready ? { imageUrl: '/iris/api/core/artifact/' + encodeURIComponent(firstArtifactId) + '/media' } : {}),
+    text: ready
+      ? '[iris] 图像任务已完成（' + submitted.model + '，Core task: ' + submitted.task.id + '）'
+      : '[iris] 图像任务已提交并由 Core 后台观察（' + submitted.model + '，Core task: ' + submitted.task.id + '）'
   };
 });
 
 /* ---------- 🎬 视频生成 ---------- */
 register('video', async (host, args, { signal }) => {
   const prompt = String(args.prompt || '').trim();
-  if (!prompt && !args.audio_path) throw new Error('iris: prompt 不能为空');
   const frame = resolveFirstFrameFile(args);
   const providers = selectProviders(cap.CAPABILITIES.VIDEO, '视频', args.model);
   const routes = providers.map((provider) => videoRoute(provider, args, frame));
-  const submitted = await submitVideoV2(routes, frame, prompt, args, signal);
+  // s2v 数字人需要在受理边界前按候选上传首帧+音频，暂留 legacy 链路（见 DSH_CORE_MIGRATION）。
+  // 判定看显式意图（audio_path 或 model 指定 s2v），不看候选池——池里登记 s2v 模型
+  // 不应把 t2v/i2v 请求挡回 legacy。
+  const hasAudioPath = Boolean(String(args.audio_path || '').trim());
+  const s2v = hasAudioPath || (args.model && /s2v/i.test(String(args.model)));
+  // B-7：audio_path 与选中模型必须语义一致。若用户提供了音频却选中非 s2v 模型，
+  // 旧实现会落入 else 分支静默丢弃 audio_path 并生成普通视频（可能产生非预期计费）。
+  // 这里在受理边界与任何网络调用之前明确拒绝，不猜测用户意图。
+  if (hasAudioPath && routes.some((route) => !route.s2vModel)) {
+    const mismatched = routes.filter((route) => !route.s2vModel).map((route) => route.model).join(', ');
+    throw new Error('iris: audio_path 只能配合支持 s2v 数字人的模型；当前候选 ' + mismatched
+      + ' 不是 s2v 模型。请改用 s2v 模型（如 wan2.2-s2v-flash），或移除 audio_path 走文生/图生视频。');
+  }
+  if (s2v) {
+    if (!prompt && !args.audio_path) throw new Error('iris: prompt 不能为空');
+    const submitted = await submitVideoV2(routes, frame, prompt, args, signal);
+    return {
+      ok: true, storage: 'legacy', taskId: submitted.task.id, model: submitted.model, mode: submitted.task.mode,
+      providerId: submitted.provider.id, remoteTaskId: submitted.remoteTaskId,
+      text: '[iris] 视频任务已提交（' + submitted.model + '，task: ' + submitted.task.id + '）'
+    };
+  }
+  const coreRoutes = routes.filter((route) => !route.isS2V);
+  if (!coreRoutes.length) {
+    throw new Error('iris: 当前视频候选只有 s2v 数字人模型；请使用 audio_path 的数字人入口');
+  }
+  const submitted = await submitCoreVideo(coreRoutes, frame, prompt, args, signal);
+  const firstArtifactId = submitted.task.artifactIds[0];
+  const ready = submitted.task.outcome === 'succeeded'
+    && submitted.task.deliveryState === 'ready' && Boolean(firstArtifactId);
   return {
-    ok: true, taskId: submitted.task.id, model: submitted.model, mode: submitted.task.mode,
-    providerId: submitted.provider.id, remoteTaskId: submitted.remoteTaskId,
-    text: '[iris] 视频任务已提交（' + submitted.model + '，task: ' + submitted.task.id + '）'
+    ok: true, storage: 'core', taskId: submitted.task.id, model: submitted.model, mode: submitted.mode,
+    providerId: submitted.provider.id, remoteTaskId: submitted.task.remoteTaskId || null,
+    artifactIds: submitted.task.artifactIds,
+    ...(ready ? { videoUrl: '/iris/api/core/artifact/' + encodeURIComponent(firstArtifactId) + '/media' } : {}),
+    text: ready
+      ? '[iris] 视频任务已完成（' + submitted.model + '，Core task: ' + submitted.task.id + '）'
+      : '[iris] 视频任务已提交并由 Core 后台观察（' + submitted.model + '，Core task: ' + submitted.task.id + '）'
   };
 });
 
+/**
+ * DSH 语音合成入口（E2）：TTS 是同步完成型——submit 内 completed，同一次调用
+ * 直接交付 generated-audio Artifact（无 remote 长轮询）。整条候选链共用一个
+ * voice（Core providerInput 静态；legacy 曾按候选各自取 provider.ttsVoice）。
+ */
+async function submitCoreTts(routes, normalizedInput, signal) {
+  const voice = normalizedInput.voice || String(routes[0].provider.ttsVoice || '').trim();
+  const { providerInput } = normalizeGenerationInput('tts', {
+    text: normalizedInput.text, ...(voice ? { voice } : {})
+  });
+  const submitted = await submitProviderTaskForDsh({
+    capability: 'tts',
+    candidates: routes.map((route) => ({
+      adapter: route.adapter,
+      model: route.modelRef,
+      selectionReason: route.selectionReason,
+      providerBinding: providerTaskBinding(route.provider)
+    })),
+    providerInput,
+    signal
+  });
+  const task = submitted.task;
+  recordCoreTaskAttemptHealth(task, cap.CAPABILITIES.TTS);
+  if (submitted.localError) throw taskActionError(task.id, 'Core 提交结果未能可靠落盘，已停止后续候选', submitted.localError);
+  if (task.acceptance === 'unknown') throw taskActionError(task.id, '语音合成受理状态未知，禁止自动重提', task.lastError);
+  if (task.acceptance === 'not_accepted') throw taskActionError(task.id, '所有候选均明确未受理', task.attempts);
+  if (task.outcome === 'succeeded' && task.deliveryState === 'failed') {
+    throw taskActionError(task.id, '语音已合成，但 Core Artifact 交付失败；禁止重新生成', task.lastError);
+  }
+  if (task.outcome !== 'succeeded' || task.deliveryState !== 'ready' || !task.artifactIds.length) {
+    throw taskActionError(task.id, '语音合成没有得到可交付产物；事实已保留在 Core，未回退重提', task);
+  }
+  const selected = routes.find((route) => route.provider.id === task.providerId && route.modelRef === task.modelRef);
+  if (!selected) throw taskActionError(task.id, 'Core Task 的供应商身份无法映射回当前路由', task);
+  return { task, provider: selected.provider, model: selected.model };
+}
+
 /* ---------- 🔊 语音合成 ---------- */
 register('tts', async (host, args, { signal }) => {
-  const text = String(args.text || '').trim();
-  if (!text) throw new Error('iris: text 不能为空');
+  const { providerInput } = normalizeGenerationInput('tts', {
+    text: args.text, voice: optionalActionText(args.voice)
+  });
   const providers = selectProviders(cap.CAPABILITIES.TTS, '语音', args.model);
-  const routes = providers.map((provider) => ({
-    ...simpleModelRoute(provider, args, 'ttsModel', 'qwen-tts-latest'),
-    voice: args.voice || provider.ttsVoice || 'Cherry'
-  }));
-  const submitted = await submitTtsV2(routes, text, args, signal);
+  const routes = providers.map((provider) => simpleModelRoute(provider, args, cap.CAPABILITIES.TTS));
+  const submitted = await submitCoreTts(routes, providerInput, signal);
+  const firstArtifactId = submitted.task.artifactIds[0];
   return {
-    ok: true, taskId: submitted.task.id, model: submitted.model, providerId: submitted.provider.id,
-    text: '[iris] 语音已合成（' + submitted.model + '，task: ' + submitted.task.id + '）'
+    ok: true, storage: 'core', taskId: submitted.task.id, model: submitted.model,
+    providerId: submitted.provider.id,
+    artifactIds: submitted.task.artifactIds,
+    audioUrl: '/iris/api/core/artifact/' + encodeURIComponent(firstArtifactId) + '/media',
+    text: '[iris] 语音已合成（' + submitted.model + '，Core task: ' + submitted.task.id + '）'
   };
 });
 
+/**
+ * DSH 转写入口（E3）：上传型异步——音频先在 Host 边界上传到首选候选的临时存储
+ * （签名 URL 只进 providerInput，绝不落 Core 记录），再经受理边界提交；观察/接管
+ * 与人工控制面复用同一 Task/Attempt 轴；正文物化为 text/plain transcript Artifact。
+ * 已知边界：临时音频 URL 属于首选候选的账号，failover 到不同账号时如实记录失败。
+ */
+async function submitCoreTranscribe(routes, normalized, signal) {
+  let providerInput = normalized.providerInput;
+  if (normalized.audioPath) {
+    const prepared = await prepareProviderInput(routes[0].adapter, {
+      model: routes[0].model, filePath: normalized.audioPath, signal
+    });
+    providerInput = normalizeGenerationInput('transcribe', { audio_url: prepared.url }).providerInput;
+  }
+  const submitted = await submitProviderTaskForDsh({
+    capability: 'transcribe',
+    candidates: routes.map((route) => ({
+      adapter: route.adapter,
+      model: route.modelRef,
+      selectionReason: route.selectionReason,
+      providerBinding: providerTaskBinding(route.provider)
+    })),
+    providerInput,
+    signal
+  });
+  const task = submitted.task;
+  recordCoreTaskAttemptHealth(task, cap.CAPABILITIES.TRANSCRIBE);
+  if (submitted.localError) throw taskActionError(task.id, 'Core 提交结果未能可靠落盘，已停止后续候选', submitted.localError);
+  if (task.acceptance === 'unknown') throw taskActionError(task.id, '转写受理状态未知，禁止自动重提', task.lastError);
+  if (task.acceptance === 'not_accepted') throw taskActionError(task.id, '所有候选均明确未受理', task.attempts);
+  if (task.outcome === 'succeeded' && task.deliveryState === 'failed') {
+    throw taskActionError(task.id, '转写已完成，但 Core Artifact 交付失败；禁止重新生成', task.lastError);
+  }
+  const selected = routes.find((route) => route.provider.id === task.providerId && route.modelRef === task.modelRef);
+  if (!selected) throw taskActionError(task.id, 'Core Task 的供应商身份无法映射回当前路由', task);
+  if (task.acceptance === 'accepted' && task.remoteTaskId
+      && ['none', 'unknown'].includes(task.outcome) && task.phase !== 'terminal') {
+    await watchProviderTaskForDsh({ taskId: task.id, signal });
+  } else if (task.outcome !== 'succeeded' || task.deliveryState !== 'ready' || !task.artifactIds.length) {
+    throw taskActionError(task.id, '转写路由没有得到可观察任务或可交付产物；事实已保留在 Core，未回退重提', task);
+  }
+  return { task, provider: selected.provider, model: selected.model };
+}
+
 /* ---------- 👁 看图 ---------- */
 register('look', async (host, args, { signal }) => {
   const p = String(args.image_path || '').trim();
@@ -790,23 +762,28 @@ register('crop', async (host, args, { signal }) => {
   const p = String(args.image_path || '').trim();
   if (!p || !path.isAbsolute(p)) throw new Error('iris: image_path 必须是绝对路径');
   if (!fs.existsSync(p)) throw new Error('iris: 图片不存在');
-  const { buffer, width, height, mime } = await cropImage({ input: p, left: args.left, top: args.top, width: args.width, height: args.height });
-  const b64 = buffer.toString('base64');
-  return { ok: true, text: `[iris] 裁剪完成：${width}x${height}（原区域 ${args.left},${args.top},${args.width},${args.height}）`, imageDataUrl: `data:${mime};base64,${b64}` };
+  const result = await cropForDsh({
+    imagePath: p, left: args.left, top: args.top, width: args.width, height: args.height, signal
+  });
+  const b64 = result.bytes.toString('base64');
+  return { ok: true, text: `[iris] 裁剪完成：${result.width}x${result.height}（原区域 ${args.left},${args.top},${args.width},${args.height}）`, imageDataUrl: `data:${result.mediaType};base64,${b64}` };
 });
 
 /* ---------- 📷 像素 diff ---------- */
 register('diff', async (host, args, { signal }) => {
   if (!args.image_a_path || !args.image_b_path) throw new Error('iris: 需要 image_a_path 和 image_b_path');
-  const { ratio, diffPixels, totalPixels, width, height, worstRegions, heatmap, mime } = await pixelDiff({
-    inputA: args.image_a_path, inputB: args.image_b_path, grid: args.grid || 8, topRegions: args.top_regions || 3
+  const result = await diffForDsh({
+    imageA: { imagePath: args.image_a_path }, imageB: { imagePath: args.image_b_path },
+    grid: args.grid, topRegions: args.top_regions, signal
   });
+  const { ratio, diffPixels, totalPixels, width, height, worstRegions } = result.metrics;
   const pct = (ratio * 100).toFixed(2);
   const regions = worstRegions.map((r) => `(col ${r.col},row ${r.row}) ${(r.score * 100).toFixed(1)}%`).join(' ');
   return {
     ok: true,
+    artifactIds: [result.artifact.id],
     text: `[iris] 像素差异 ${pct}%（${diffPixels}/${totalPixels}px，归一化 ${width}x${height}）\n最差区域（${worstRegions.length} 格）: ${regions}`,
-    imageDataUrl: `data:${mime};base64,${heatmap.toString('base64')}`
+    imageDataUrl: `data:${result.mediaType};base64,${result.bytes.toString('base64')}`
   };
 });
 
@@ -849,20 +826,49 @@ register('ocr', async (host, args, { signal }) => {
 
 /* ---------- 📋 任务查询 ---------- */
 register('status', async (host, args, { signal }) => {
-  if (args.task_id) {
-    const t = tasks.get(String(args.task_id).trim());
-    if (!t) throw new Error('iris: 没有这个任务：' + args.task_id);
-    const lines = [`[${t.cap}] ${t.id} · ${t.status}${t.progress ? ' · ' + t.progress : ''} · ${t.model}`];
-    if (t.prompt) lines.push('prompt: ' + String(t.prompt).slice(0, 120));
-    if (t.error) lines.push('error: ' + t.error);
-    if ((t.files || []).length) lines.push('files:\n' + t.files.map((f) => path.join(outputDir(), f)).join('\n'));
-    const links = mediaLinksOf(t);
-    if (links.length) lines.push('links:\n' + links.join('\n'));
-    return { ok: true, text: lines.join('\n') };
+  const requestedId = String(args.task_id || '').trim();
+  if (requestedId) {
+    const legacy = tasks.get(requestedId);
+    if (legacy) {
+      const lines = [`[${legacy.cap}] ${legacy.id} · ${legacy.status}${legacy.progress ? ' · ' + legacy.progress : ''} · ${legacy.model}`];
+      if (legacy.prompt) lines.push('prompt: ' + String(legacy.prompt).slice(0, 120));
+      if (legacy.error) lines.push('error: ' + legacy.error);
+      if ((legacy.files || []).length) lines.push('files:\n' + legacy.files.map((f) => path.join(outputDir(), f)).join('\n'));
+      const links = mediaLinksOf(legacy);
+      if (links.length) lines.push('links:\n' + links.join('\n'));
+      return { ok: true, storage: 'legacy', taskId: legacy.id, text: lines.join('\n') };
+    }
+    if (/^task_[a-f0-9]{24}$/.test(requestedId)) {
+      try {
+        const core = await inspectProviderTaskForDsh(requestedId, { signal });
+        const lines = [`[${core.capability}] ${core.id} · Core ${core.phase} · ${core.outcome} / ${core.deliveryState} · ${core.modelRef || '未选择模型'}`];
+        if (core.lastError) lines.push('error: ' + core.lastError.safeMessage);
+        if (core.remoteTaskId) lines.push('remoteTask: ' + core.remoteTaskId);
+        if (core.artifactIds.length) {
+          lines.push('artifacts:\n' + core.artifactIds.map((id) => id + ' · /iris/api/core/artifact/' + encodeURIComponent(id) + '/media').join('\n'));
+        }
+        return { ok: true, storage: 'core', taskId: core.id, artifactIds: core.artifactIds, text: lines.join('\n') };
+      } catch (_) { /* 对外统一为不存在，不暴露 Core 数据根 */ }
+    }
+    throw new Error('iris: 没有这个任务：' + args.task_id);
   }
-  const recent = tasks.list().slice(0, 5);
-  if (!recent.length) return { ok: true, text: '[iris] 还没有生成任务记录。' };
-  return { ok: true, text: recent.map((t) => `[${t.cap}] ${t.id} · ${t.status} · ${t.model}`).join('\n') };
+
+  const legacyRows = tasks.list().slice(0, 5).map((task) => ({
+    at: task.createdAt,
+    text: `[${task.cap}] ${task.id} · ${task.status} · ${task.model}`
+  }));
+  let coreRows = [];
+  try {
+    const snapshot = await coreSnapshotForDsh({ limit: 5, signal });
+    coreRows = (snapshot.tasks.recent || []).map((task) => ({
+      at: task.updatedAt,
+      text: `[${task.capability}] ${task.id} · Core ${task.phase} · ${task.outcome} / ${task.deliveryState} · ${task.modelRef || '未选择模型'}`
+    }));
+  } catch (_) { /* legacy 查询仍然可用 */ }
+  const rows = legacyRows.concat(coreRows)
+    .sort((a, b) => String(b.at || '').localeCompare(String(a.at || '')))
+    .slice(0, 5);
+  return { ok: true, text: rows.length ? rows.map((item) => item.text).join('\n') : '[iris] 还没有生成任务记录。' };
 });
 
 /* ---------- Task v2 人工接管 ---------- */
@@ -1096,8 +1102,10 @@ register('providers_list', async (host, args) => {
       name: p.name || p.id,
       type: p.type || 'openai',
       baseUrl: p.baseUrl,
+      mediaBaseUrl: p.mediaBaseUrl || '',
       enabled: p.enabled !== false,
-      mediaProtocol: p.mediaProtocol || inferMediaProtocol(p.baseUrl),
+      auth: p.auth === 'none' ? 'none' : 'bearer',
+      ...selectMediaProtocol(p),
       apiKeyHint: String(p.apiKey || '').length <= 8 ? '****' : String(p.apiKey).slice(0, 3) + '****' + String(p.apiKey).slice(-4),
       models: models.providerModels(p).map((m) => ({
         id: m.id,
@@ -1117,7 +1125,7 @@ register('providers_list', async (host, args) => {
 register('providers_upsert', async (host, args) => {
   const id = args.id || undefined;
   const patch = { id };
-  const allowed = ['name', 'type', 'baseUrl', 'apiKey', 'enabled', 'mediaProtocol',
+  const allowed = ['auth', 'name', 'type', 'baseUrl', 'mediaBaseUrl', 'apiKey', 'enabled', 'mediaProtocol',
     'imageModel', 'videoModel', 'ttsModel', 'transcribeModel', 'visionModel', 'models'];
   for (const key of allowed) {
     if (Object.prototype.hasOwnProperty.call(args, key)) patch[key] = args[key];
@@ -1141,30 +1149,30 @@ register('providers_set_models', async (host, args) => {
 });
 
 /**
- * 模型发现（P2）：GET /models 拉全量 → 按规则过滤出媒体能力模型 → 写入显式池。
+ * 模型发现：读取供应商目录 → 官方能力元数据优先、名称规则兜底 → 写入显式池。
  * 免费只读；拉不到/不支持则原样保留现有池（优雅降级），报人话错误。
  */
 register('providers_discover', async (host, args, { signal }) => {
   const p = store.providerById(String(args.id || ''));
   if (!p) throw new Error('iris: 供应商不存在或未启用');
-  let ids;
+  let discoveredModels;
   try {
     const providerAdapter = createConfiguredProviderAdapter(p);
     const discovered = await invokeProviderOperation(providerAdapter, 'discover', { signal });
-    ids = discovered.models.map((model) => model.id);
+    discoveredModels = discovered.models;
   } catch (err) {
     throw new Error('iris: 模型发现失败（保留现有池）：' + String(err.message || err));
   }
   const media = [];
-  for (const id of ids) {
-    const caps = models.capabilitiesOfModel(id);
-    if (caps.length) media.push({ id, capabilities: caps });
+  for (const model of discoveredModels) {
+    const caps = models.capabilitiesOfDiscoveredModel(model);
+    if (caps.length) media.push({ id: model.id, capabilities: caps });
   }
   if (!media.length) {
-    return { ok: true, total: ids.length, media: 0, text: `[iris] ${p.name}：拉到 ${ids.length} 个模型，无媒体能力匹配——可在模型池区手动添加并标能力` };
+    return { ok: true, total: discoveredModels.length, media: 0, text: `[iris] ${p.name}：拉到 ${discoveredModels.length} 个模型，无媒体能力匹配——可在模型池区手动添加并标能力` };
   }
-  store.setProviderModels(p.id, media);
-  return { ok: true, total: ids.length, media: media.length, text: `[iris] ${p.name}：发现 ${ids.length} 个模型，${media.length} 个媒体能力模型已入池（按能力标注）` };
+  store.mergeDiscoveredModels(p.id, media);
+  return { ok: true, total: discoveredModels.length, media: media.length, text: `[iris] ${p.name}：发现 ${discoveredModels.length} 个模型，${media.length} 个媒体能力模型已入池（官方元数据优先）` };
 });
 
 /** 能力实测（红色测试图）：对某供应商的 vision 模型跑 testVisionCapability */
@@ -1213,9 +1221,9 @@ async function probeModel(host, p, modelId, capability, signal) {
     return { skipped: true, ok: false, note: '需真实音频，请通过“音频转写”动作验证' };
   }
   if (capability === cap.CAPABILITIES.TTS) {
-    const providerAdapter = createConfiguredProviderAdapter(p, { protocol: 'dashscope' });
+    const providerAdapter = createConfiguredProviderAdapter(p);
     const submitted = await invokeProviderOperation(providerAdapter, 'submit', {
-      capability: 'tts', model: modelId, input: { text: '你好', voice: 'Cherry' }, signal
+      capability: 'tts', model: modelId, input: { text: '你好' }, signal
     });
     const value = submitted.kind === 'completed' ? submitted.value : null;
     const ok = Boolean(value && (value.audioUrl || value.audioB64));
@@ -1436,41 +1444,45 @@ register('attachment_export', async (host, args, { signal }) => {
 /* ============ 音频转写（阶段 7.2） ============ */
 
 register('transcribe', async (host, args, { signal }) => {
-  const audioPath = String(args.audio_path || '').trim();
-  if (!audioPath || !path.isAbsolute(audioPath)) throw new Error('iris: audio_path 必须是绝对路径');
-  if (!fs.existsSync(audioPath)) throw new Error('iris: 音频文件不存在');
+  const normalized = normalizeGenerationInput('transcribe', {
+    audio_url: args.audio_url, audio_path: args.audio_path
+  }, { allowAudioPath: true });
+  if (normalized.audioPath && !fs.existsSync(normalized.audioPath)) throw new Error('iris: 音频文件不存在');
   const providers = selectProviders(cap.CAPABILITIES.TRANSCRIBE, '转写', args.model);
   const routes = providers.map((provider) =>
-    simpleModelRoute(provider, args, 'transcribeModel', 'qwen-audio-3.0-asr-flash-filetrans')
+    simpleModelRoute(provider, args, cap.CAPABILITIES.TRANSCRIBE)
   );
-  const submitted = await submitTranscriptionV2(routes, audioPath, args, signal);
+  const submitted = await submitCoreTranscribe(routes, normalized, signal);
+  const firstArtifactId = submitted.task.artifactIds[0];
+  const ready = submitted.task.outcome === 'succeeded'
+    && submitted.task.deliveryState === 'ready' && Boolean(firstArtifactId);
   return {
-    ok: true, taskId: submitted.task.id, model: submitted.model, providerId: submitted.provider.id,
-    remoteTaskId: submitted.remoteTaskId,
-    text: '[iris] 音频转写任务已提交（' + submitted.model + '，task: ' + submitted.task.id + '）'
+    ok: true, storage: 'core', taskId: submitted.task.id, model: submitted.model,
+    providerId: submitted.provider.id, remoteTaskId: submitted.task.remoteTaskId || null,
+    artifactIds: submitted.task.artifactIds,
+    ...(ready ? { transcriptUrl: '/iris/api/core/artifact/' + encodeURIComponent(firstArtifactId) + '/media' } : {}),
+    text: ready
+      ? '[iris] 音频转写已完成（' + submitted.model + '，Core task: ' + submitted.task.id + '）'
+      : '[iris] 音频转写任务已提交并由 Core 后台观察（' + submitted.model + '，Core task: ' + submitted.task.id + '）'
   };
 });
 
 /* ============ 视频抽帧（阶段 7.1） ============ */
 
 register('video_frames', async (host, args, { signal }) => {
-  const p = String(args.video_path || '').trim();
-  if (!p || !path.isAbsolute(p)) throw new Error('iris: video_path 必须是绝对路径');
-  if (!fs.existsSync(p)) throw new Error('iris: 视频文件不存在');
-  if (!ffmpegAvailable()) throw new Error('iris: ffmpeg/ffprobe 不可用，无法抽帧（可选安装 ffmpeg 后启用）');
-  const meta = probeVideo(p);
-  const frames = await extractFrames({
-    inputPath: p, maxFrames: args.max_frames, targetWidth: args.target_width,
-    format: args.format || 'jpeg', quality: args.quality, signal
+  const { media: meta, frames } = await framesForDsh({
+    videoPath: args.video_path, maxFrames: args.max_frames, targetWidth: args.target_width,
+    format: optionalActionText(args.format), quality: args.quality, signal
   });
-  const mime = args.format === 'png' ? 'image/png' : 'image/jpeg';
+  const mime = frames[0].mediaType;
   const summary = frames.map((f, i) =>
-    `帧${i + 1} @${f.atSec.toFixed(1)}s  ${f.width}x${f.height}  ${(f.buffer.length / 1024).toFixed(0)}KB`
+    `帧${i + 1} @${f.atSec.toFixed(1)}s  ${f.width}x${f.height}  ${(f.bytes.length / 1024).toFixed(0)}KB`
   ).join('\n');
   // 首帧预览 base64
-  const firstFrame = `data:${mime};base64,${frames[0].buffer.toString('base64')}`;
+  const firstFrame = `data:${mime};base64,${frames[0].bytes.toString('base64')}`;
   return {
     ok: true,
+    artifactIds: frames.map((frame) => frame.artifact.id),
     text: `[iris] 视频抽帧完成：${frames.length} 帧（${meta.durationSec.toFixed(1)}s ${meta.width}x${meta.height}，${mime === 'image/png' ? 'PNG' : 'JPEG'}）\n${summary}\n\n（预览为首帧；全部帧请用对话工具 iris_video_frames 获取 attachment）`,
     imageDataUrl: firstFrame
   };