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

package/lib/flow-store.js

@@ -10,6 +10,8 @@ import { parseModelRef } from './models.js';
 import { inspectLocalRequestRoot } from './local-request-root.js';
 import { normalizeComfyParameters } from './comfyui-workflow.js';
 import { AUDIO_RECIPES, isAudioRecipe, normalizeAudioFlowInput } from './audio-flow-input.js';
+import { VIDEO_RECIPE, normalizeVideoFlowInput } from './video-flow-input.js';
+import { checkedNetworkRequirement } from './network-policy.js';
 
 const RUN = /^run_[a-f0-9]{24}$/;
 const TASK = /^task_[a-f0-9]{24}$/;
@@ -32,27 +34,34 @@ function iso(value) { return typeof value === 'string' && Number.isFinite(Date.p
 const copy = value => Object.freeze(structuredClone(value));
 export const flowId = prefix => prefix + '_' + crypto.randomBytes(12).toString('hex');
 export const flowSha256 = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
-export const flowStepId = run => isAudioRecipe(run.recipe) ? AUDIO_RECIPES[run.recipe].step : run.recipe === IMAGE_GENERATE_RECIPE ? 'generate' : 'edit';
-export const flowCapability = run => isAudioRecipe(run.recipe) ? AUDIO_RECIPES[run.recipe].capability : 'image';
+export const flowStepId = run => run.recipe === VIDEO_RECIPE ? 'video' : isAudioRecipe(run.recipe) ? AUDIO_RECIPES[run.recipe].step : run.recipe === IMAGE_GENERATE_RECIPE ? 'generate' : 'edit';
+export const flowCapability = run => run.recipe === VIDEO_RECIPE ? 'video' : isAudioRecipe(run.recipe) ? AUDIO_RECIPES[run.recipe].capability : 'image';
 export const flowStep = run => run[flowStepId(run)];
 export function requireImageGenerationRoot(root) {
-  if (![2, 3].includes(inspectLocalRequestRoot(root, { allowAbsent: true })?.schemaVersion)) {
+  if (![2, 3, 4].includes(inspectLocalRequestRoot(root, { allowAbsent: true })?.schemaVersion)) {
     flowFail('IRIS_FLOW_GENERATION_ROOT_REQUIRED', '文生图需要新的专用执行根：execution init --image-generation；不迁移已有根');
   }
 }
 export function requireAudioRoot(root) {
-  if (inspectLocalRequestRoot(root, { allowAbsent: true })?.schemaVersion !== 3) {
+  if (![3, 4].includes(inspectLocalRequestRoot(root, { allowAbsent: true })?.schemaVersion)) {
     flowFail('IRIS_FLOW_AUDIO_ROOT_REQUIRED', '音频需要新的专用执行根：execution init --audio；不迁移已有根');
   }
 }
 
+export function requireVideoRoot(root) {
+  if (inspectLocalRequestRoot(root, { allowAbsent: true })?.schemaVersion !== 4) {
+    flowFail('IRIS_FLOW_VIDEO_ROOT_REQUIRED', '文生视频需要新的专用 execution init --video 根；原根不迁移');
+  }
+}
+
 export function validFlowBinding(value) {
   return keys(value, ['runId', 'stepId', 'inputDigest']) && RUN.test(value.runId)
-    && ['edit', 'generate', 'speak', 'transcribe'].includes(value.stepId) && BINDING.test(value.inputDigest);
+    && ['edit', 'generate', 'speak', 'transcribe', 'video'].includes(value.stepId) && BINDING.test(value.inputDigest);
 }
 export function flowTaskBinding(run) { return { runId: run.id, stepId: flowStepId(run), inputDigest: run.inputDigest }; }
 
-function inputDigest(run) {
+function legacyInputDigest(run) {
+  if (run.recipe === VIDEO_RECIPE) return 'sha256:' + flowSha256(JSON.stringify([VIDEO_RECIPE, run.providerBinding, normalizeVideoFlowInput(run.input)]));
   if (isAudioRecipe(run.recipe)) return 'sha256:' + flowSha256(JSON.stringify([run.recipe, run.providerBinding,
     normalizeAudioFlowInput(run.recipe, run.input), run.source?.sha256 ?? null]));
   if (run.recipe === IMAGE_GENERATE_RECIPE) return 'sha256:' + flowSha256(JSON.stringify([IMAGE_GENERATE_RECIPE,
@@ -62,13 +71,24 @@ function inputDigest(run) {
     run.input.model_ref, run.providerBinding, run.input.prompt, run.input.size ?? null, 1]));
 }
 
+function networkPart(value) {
+  if (value?.networkRequirement === undefined) return {};
+  try { return { networkRequirement: checkedNetworkRequirement(value.networkRequirement) }; }
+  catch (_) { flowFail('IRIS_FLOW_RECORD_INVALID', '流程网络要求身份或版本无效'); }
+}
+function inputDigest(run) {
+  const base = legacyInputDigest(run);
+  return run.networkRequirement === undefined ? base
+    : 'sha256:' + flowSha256(JSON.stringify(['network-flow/v1', base, networkPart(run).networkRequirement]));
+}
+
 function reference(value) { return keys(value, ['artifactId', 'sha256']) && ARTIFACT.test(value.artifactId) && SHA.test(value.sha256); }
 function validateAudio(run, expectedId) {
   let normalized;
   try { normalized = normalizeAudioFlowInput(run.recipe, run.input); }
   catch (_) { flowFail('IRIS_FLOW_RECORD_INVALID', '音频流程输入无效'); }
   const step = flowStepId(run), transcribe = run.recipe === 'transcribe/v0';
-  if (!keys(run, ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'input', 'providerBinding', 'inputDigest', step, 'source', 'output'],
+  if (!keys(run, ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'input', 'providerBinding', 'inputDigest', step, 'source', 'output', 'networkRequirement'],
     ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'input', 'providerBinding', 'inputDigest', step, ...(transcribe ? ['source'] : [])])
       || run.schemaVersion !== 3 || !RUN.test(run.id) || run.id !== expectedId || !Number.isSafeInteger(run.revision) || run.revision < 1
       || !iso(run.createdAt) || !iso(run.updatedAt) || !BINDING.test(run.providerBinding)
@@ -83,7 +103,7 @@ function validateAudio(run, expectedId) {
 }
 function validateGeneration(run, expectedId, normalized) {
   if (!keys(run, ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'input', 'providerBinding',
-    'inputDigest', 'generate', 'output', 'selection'],
+    'inputDigest', 'generate', 'output', 'selection', 'networkRequirement'],
   ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'input', 'providerBinding', 'inputDigest', 'generate'])
       || run.schemaVersion !== (run.input?.workflow_parameters === undefined ? 1 : 2) || run.recipe !== IMAGE_GENERATE_RECIPE || !RUN.test(run.id) || run.id !== expectedId
       || !Number.isSafeInteger(run.revision) || run.revision < 1 || !iso(run.createdAt) || !iso(run.updatedAt)
@@ -102,13 +122,26 @@ function validateGeneration(run, expectedId, normalized) {
   return run;
 }
 function validate(run, expectedId) {
+  networkPart(run);
+  if (run?.recipe === VIDEO_RECIPE) {
+    let normalized;
+    try { normalized = normalizeVideoFlowInput(run.input); } catch (_) { flowFail('IRIS_FLOW_RECORD_INVALID', '视频流程输入无效'); }
+    if (!keys(run, ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'input', 'providerBinding', 'inputDigest', 'video', 'output', 'networkRequirement'],
+      ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'input', 'providerBinding', 'inputDigest', 'video'])
+        || run.schemaVersion !== 4 || run.id !== expectedId || !RUN.test(run.id) || !Number.isSafeInteger(run.revision) || run.revision < 1
+        || !iso(run.createdAt) || !iso(run.updatedAt) || !BINDING.test(run.providerBinding)
+        || JSON.stringify(run.input) !== JSON.stringify(normalized) || run.inputDigest !== inputDigest(run)
+        || !keys(run.video, ['taskId', 'claimed']) || !TASK.test(run.video.taskId) || typeof run.video.claimed !== 'boolean'
+        || run.output !== undefined && (!reference(run.output) || !run.video.claimed)) flowFail('IRIS_FLOW_RECORD_INVALID', '视频流程记录或绑定摘要冲突');
+    return run;
+  }
   if (isAudioRecipe(run?.recipe)) return validateAudio(run, expectedId);
   let normalized;
   try { normalized = normalizeGenerationInput('image', run?.input); }
   catch (_) { flowFail('IRIS_FLOW_RECORD_INVALID', '流程创作输入无效'); }
   if (run.recipe === IMAGE_GENERATE_RECIPE) return validateGeneration(run, expectedId, normalized);
   if (!keys(run, ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'source', 'input', 'providerBinding',
-    'inputDigest', 'edit', 'compare', 'output', 'comparison', 'selection'],
+    'inputDigest', 'edit', 'compare', 'output', 'comparison', 'selection', 'networkRequirement'],
   ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'source', 'input', 'providerBinding', 'inputDigest', 'edit', 'compare'])
       || run.schemaVersion !== 0 || run.recipe !== RECIPE || !RUN.test(run.id) || run.id !== expectedId
       || !Number.isSafeInteger(run.revision) || run.revision < 1 || !iso(run.createdAt) || !iso(run.updatedAt)
@@ -185,28 +218,41 @@ export function readFlowRun(root, id) {
     throw error;
   }
   validate(record, id);
+  if (record.recipe === VIDEO_RECIPE) requireVideoRoot(root);
   if (isAudioRecipe(record.recipe)) requireAudioRoot(root);
   if (record.recipe === IMAGE_GENERATE_RECIPE) requireImageGenerationRoot(root);
   return copy(record);
 }
 
 /** Internal immutable creation intent; HTTP callers cannot choose these identities. */
-export function prepareFlowCreation({ source, input, providerBinding, recipe }) {
-  if (isAudioRecipe(recipe)) return { recipe, runId: flowId('run'), taskId: flowId('task'), createdAt: new Date().toISOString(),
+export function prepareFlowCreation({ source, input, providerBinding, recipe, networkRequirement }) {
+  const network = networkPart({ networkRequirement });
+  if (recipe === VIDEO_RECIPE) return { ...network, recipe, runId: flowId('run'), taskId: flowId('task'), createdAt: new Date().toISOString(), input, providerBinding };
+  if (isAudioRecipe(recipe)) return { ...network, recipe, runId: flowId('run'), taskId: flowId('task'), createdAt: new Date().toISOString(),
     ...(source ? { source } : {}), input, providerBinding };
-  if (!source) return { recipe: IMAGE_GENERATE_RECIPE, runId: flowId('run'), taskId: flowId('task'),
+  if (!source) return { ...network, recipe: IMAGE_GENERATE_RECIPE, runId: flowId('run'), taskId: flowId('task'),
     createdAt: new Date().toISOString(), input, providerBinding };
-  return { runId: flowId('run'), taskId: flowId('task'), comparisonArtifactId: flowId('artifact'),
+  return { ...network, runId: flowId('run'), taskId: flowId('task'), comparisonArtifactId: flowId('artifact'),
     createdAt: new Date().toISOString(), source, input, providerBinding };
 }
 
 export function validateFlowCreation(intent) {
+  if (!intent || typeof intent !== 'object' || Array.isArray(intent)) flowFail('IRIS_FLOW_RECORD_INVALID', '流程创建意图无效');
+  const network = networkPart(intent);
+  const { networkRequirement, ...payload } = intent;
+  intent = payload;
+  if (intent?.recipe === VIDEO_RECIPE) {
+    if (!keys(intent, ['recipe', 'runId', 'taskId', 'createdAt', 'input', 'providerBinding'])) flowFail('IRIS_FLOW_RECORD_INVALID', '视频创建意图无效');
+    const record = { ...network, schemaVersion: 4, recipe: VIDEO_RECIPE, id: intent.runId, revision: 1, createdAt: intent.createdAt, updatedAt: intent.createdAt,
+      input: intent.input, providerBinding: intent.providerBinding, video: { taskId: intent.taskId, claimed: false } };
+    record.inputDigest = inputDigest(record); return validate(record, record.id);
+  }
   if (isAudioRecipe(intent?.recipe)) {
     if (!keys(intent, ['recipe', 'runId', 'taskId', 'createdAt', 'input', 'providerBinding', 'source'],
       ['recipe', 'runId', 'taskId', 'createdAt', 'input', 'providerBinding', ...(intent.recipe === 'transcribe/v0' ? ['source'] : [])])) {
       flowFail('IRIS_FLOW_RECORD_INVALID', '音频创建意图无效');
     }
-    const record = { schemaVersion: 3, recipe: intent.recipe, id: intent.runId, revision: 1,
+    const record = { ...network, schemaVersion: 3, recipe: intent.recipe, id: intent.runId, revision: 1,
       createdAt: intent.createdAt, updatedAt: intent.createdAt, input: intent.input, providerBinding: intent.providerBinding,
       ...(intent.source ? { source: intent.source } : {}), [AUDIO_RECIPES[intent.recipe].step]: { taskId: intent.taskId, claimed: false } };
     record.inputDigest = inputDigest(record);
@@ -216,7 +262,7 @@ export function validateFlowCreation(intent) {
     if (!keys(intent, ['recipe', 'runId', 'taskId', 'createdAt', 'input', 'providerBinding'])) {
       flowFail('IRIS_FLOW_RECORD_INVALID', '文生图创建意图无效');
     }
-    const record = { schemaVersion: intent.input?.workflow_parameters === undefined ? 1 : 2, recipe: IMAGE_GENERATE_RECIPE, id: intent.runId, revision: 1,
+    const record = { ...network, schemaVersion: intent.input?.workflow_parameters === undefined ? 1 : 2, recipe: IMAGE_GENERATE_RECIPE, id: intent.runId, revision: 1,
       createdAt: intent.createdAt, updatedAt: intent.createdAt, input: intent.input,
       providerBinding: intent.providerBinding, generate: { taskId: intent.taskId, claimed: false } };
     record.inputDigest = inputDigest(record);
@@ -225,7 +271,7 @@ export function validateFlowCreation(intent) {
   if (!keys(intent, ['runId', 'taskId', 'comparisonArtifactId', 'createdAt', 'source', 'input', 'providerBinding'])) {
     flowFail('IRIS_FLOW_RECORD_INVALID', '流程创建意图无效');
   }
-  const record = { schemaVersion: 0, recipe: RECIPE, id: intent.runId, revision: 1,
+  const record = { ...network, schemaVersion: 0, recipe: RECIPE, id: intent.runId, revision: 1,
     createdAt: intent.createdAt, updatedAt: intent.createdAt, source: intent.source, input: intent.input,
     providerBinding: intent.providerBinding, edit: { taskId: intent.taskId, claimed: false },
     compare: { artifactId: intent.comparisonArtifactId } };
@@ -236,6 +282,7 @@ export function validateFlowCreation(intent) {
 export function commitFlowCreation(root, intent, { allowCreate = true } = {}) {
   inspectFlowRoot(root);
   const record = validateFlowCreation(intent);
+  if (record.recipe === VIDEO_RECIPE) requireVideoRoot(root);
   if (isAudioRecipe(record.recipe)) requireAudioRoot(root);
   if (record.recipe === IMAGE_GENERATE_RECIPE) requireImageGenerationRoot(root);
   let current;
@@ -261,7 +308,7 @@ export function createFlowRun(root, input) {
 export function updateFlowRun(root, previous, patch) {
   const current = readFlowRun(root, previous.id);
   if (current.revision !== previous.revision) flowFail('IRIS_FLOW_REVISION_CONFLICT', '流程在本次操作期间已改变');
-  const allowed = isAudioRecipe(current.recipe) ? [flowStepId(current), 'output']
+  const allowed = isAudioRecipe(current.recipe) || current.recipe === VIDEO_RECIPE ? [flowStepId(current), 'output']
     : current.recipe === IMAGE_GENERATE_RECIPE ? ['generate', 'output', 'selection'] : ['edit', 'output', 'comparison', 'selection'];
   if (!keys(patch, allowed, [])) throw new TypeError('未知流程更新字段');
   const record = { ...current, ...patch, revision: current.revision + 1, updatedAt: new Date().toISOString() };

package/lib/image-flow.js

@@ -1,17 +1,20 @@
 'use strict';
 
-import { createCoreArtifact, exportCoreArtifact, readCoreArtifactBytes } from './core-artifacts.js';
+import { createCoreArtifact, exportCoreArtifact, inspectCoreArtifactMetadata, readCoreArtifactBytes } from './core-artifacts.js';
 import { assertFlowTaskMatches, claimFlowTask, findFlowTask, recoverCoreTask } from './core-tasks.js';
 import { deliveryCacheNeedsProvider } from './core-delivery-cache.js';
 import { normalizeGenerationInput } from './generation-input.js';
+import { videoModelSupportsMode } from './video-input.js';
 import { imageEditCandidates, readImageEditArtifact } from './image-edit-input.js';
 import { parseModelRef } from './models.js';
 import { pixelDiff } from './pixels.js';
 import { createProviderTaskRunner } from './provider-task-runner.js';
 import { prepareProviderInput } from './provider-adapter.js';
+import { sameNetworkRequirement } from './network-policy.js';
+import { VIDEO_RECIPE, VIDEO_TYPES, MAX_VIDEO_BYTES, normalizeVideoFlowInput } from './video-flow-input.js';
 import { AUDIO_RECIPES, AUDIO_TYPES, isAudioRecipe, normalizeAudioFlowInput, readImportAudio } from './audio-flow-input.js';
 import { commitFlowCreation, flowFail, flowSha256, flowStep, flowStepId, initializeFlowRoot, inspectFlowRoot,
-  IMAGE_GENERATE_RECIPE, requireImageGenerationRoot, requireAudioRoot, listFlowRuns, prepareFlowCreation, readFlowRun, updateFlowRun } from './flow-store.js';
+  IMAGE_GENERATE_RECIPE, requireImageGenerationRoot, requireAudioRoot, requireVideoRoot, listFlowRuns, prepareFlowCreation, readFlowRun, updateFlowRun } from './flow-store.js';
 
 function exact(input, allowed) {
   if (!input || typeof input !== 'object' || Array.isArray(input) || Object.keys(input).some(key => !allowed.includes(key))) {
@@ -49,7 +52,7 @@ function facts(root, run) {
   }
   let status = 'not_started';
   if (task?.acceptance === 'unknown' || ['unknown', 'failed', 'canceled'].includes(task?.outcome)) status = 'needs_attention';
-  else if (task?.deliveryState === 'ready') status = isAudioRecipe(run.recipe) ? run.output ? 'ready' : 'needs_result'
+  else if (task?.deliveryState === 'ready') status = isAudioRecipe(run.recipe) || run.recipe === VIDEO_RECIPE ? run.output ? 'ready' : 'needs_result'
     : run.output && (run.recipe === IMAGE_GENERATE_RECIPE || run.comparison)
     ? run.selection ? 'selected' : 'awaiting_selection' : run.recipe === IMAGE_GENERATE_RECIPE ? 'needs_result' : 'needs_comparison';
   else if (task?.deliveryState === 'failed') status = 'delivery_failed';
@@ -57,9 +60,10 @@ function facts(root, run) {
   return { contractVersion: 0, run, task, status, ...(comparison ? { metrics: comparison.metadata } : {}) };
 }
 
-/** Fixed image/audio recipes, sharing operation-scoped leases and the original Task. */
-export function createImageFlowService(runtime, { resolveImageCandidates, resolveAudioCandidates, resolveTaskAdapter } = {}) {
+/** Fixed media recipes, sharing operation-scoped leases and the original Task. */
+export function createImageFlowService(runtime, { resolveImageCandidates, resolveAudioCandidates, resolveVideoCandidates, resolveTaskAdapter } = {}) {
   function creationInput(input) {
+    if (input?.recipe === VIDEO_RECIPE) { const { recipe, ...value } = input; return { recipe, ...normalizeVideoFlowInput(value) }; }
     if (isAudioRecipe(input?.recipe)) {
       const { recipe, ...value } = input;
       return { recipe, ...normalizeAudioFlowInput(recipe, value) };
@@ -77,13 +81,16 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
     const owned = creationInput(input);
     inspectFlowRoot(root);
     const audio = isAudioRecipe(owned.recipe);
-    if (audio) requireAudioRoot(root);
+    const video = owned.recipe === VIDEO_RECIPE;
+    if (video) requireVideoRoot(root);
+    else if (audio) requireAudioRoot(root);
     else if (!owned.source_artifact_id) requireImageGenerationRoot(root);
     const source = owned.source_artifact_id ? audio ? readAudioSource(root, owned.source_artifact_id) : await readImageEditArtifact(root, owned.source_artifact_id, signal) : null;
     const candidates = await candidatesFor(owned, signal);
     const { recipe, ...audioInput } = owned;
     return prepareFlowCreation({ ...(source ? { source: { artifactId: owned.source_artifact_id, sha256: flowSha256(source.bytes) } } : {}),
-      input: audio ? audioInput : owned, providerBinding: candidates[0].providerBinding, ...(audio ? { recipe } : {}) });
+      input: audio || video ? audioInput : owned, providerBinding: candidates[0].providerBinding,
+      ...(candidates[0].adapter.networkRequirement ? { networkRequirement: candidates[0].adapter.networkRequirement } : {}), ...(audio || video ? { recipe } : {}) });
   }
   function readAudioSource(root, id) {
     const source = readCoreArtifactBytes(root, id);
@@ -91,11 +98,16 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
     return source;
   }
   async function candidatesFor(runInput, signal, binding) {
-    const audio = isAudioRecipe(runInput.recipe), resolver = audio ? resolveAudioCandidates : resolveImageCandidates;
+    const audio = isAudioRecipe(runInput.recipe), video = runInput.recipe === VIDEO_RECIPE, resolver = video ? resolveVideoCandidates : audio ? resolveAudioCandidates : resolveImageCandidates;
+    // Keep historical records readable; restrict only creation/first dispatch.
+    if (video && !videoModelSupportsMode(parseModelRef(runInput.model_ref).modelId, 't2v')) {
+      flowFail('IRIS_VIDEO_FLOW_INPUT_INVALID', '固定文生视频流程需要匹配的模型，不接受图生视频、S2V 或参考视频模型；已有 Task 仍可按原身份观察');
+    }
     if (!resolver) flowFail('IRIS_FLOW_PROVIDER_REQUIRED', '创建或首次提交流程需要显式 Provider 配置');
     signal.throwIfAborted();
-    const candidates = await resolver({ modelRef: runInput.model_ref, signal, input: runInput,
+    const resolve = () => resolver({ modelRef: runInput.model_ref, signal, input: runInput,
       ...(audio ? { capability: AUDIO_RECIPES[runInput.recipe].capability } : {}) });
+    const candidates = await (runtime.networkWait ? runtime.networkWait(resolve, 'candidates') : resolve());
     signal.throwIfAborted();
     const parsed = parseModelRef(runInput.model_ref);
     if (!Array.isArray(candidates) || candidates.length !== 1 || candidates[0].model !== runInput.model_ref
@@ -109,7 +121,8 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
 
   async function adapterFor(task, signal) {
     if (!resolveTaskAdapter) flowFail('IRIS_FLOW_PROVIDER_REQUIRED', '观察或远端补交付需要原 Task 的 Provider 配置');
-    const adapter = await resolveTaskAdapter(task, { signal });
+    const resolve = () => resolveTaskAdapter(task, { signal });
+    const adapter = await (runtime.networkWait ? runtime.networkWait(resolve, 'candidates') : resolve());
     signal.throwIfAborted();
     return adapter;
   }
@@ -119,23 +132,26 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
     let task = facts(root, run).task;
     if (task?.attempts.length && !flowStep(run).claimed) flowFail('IRIS_FLOW_TASK_CONFLICT', '步骤检查点与已开始的 Task 冲突');
     const runner = createProviderTaskRunner(runtime);
+    if (task) runner.assertIdle(task.id);
     if (!task || !task.attempts.length) {
       const audio = isAudioRecipe(run.recipe);
-      let candidates = await candidatesFor({ ...run.input, ...(audio ? { recipe: run.recipe } : {}) }, signal, run.providerBinding);
+      const video = run.recipe === VIDEO_RECIPE;
+      let candidates = await candidatesFor({ ...run.input, ...(audio || video ? { recipe: run.recipe } : {}) }, signal, run.providerBinding);
+      if (!sameNetworkRequirement(run.networkRequirement, candidates[0].adapter.networkRequirement)) flowFail('IRIS_NETWORK_REQUIREMENT_MISMATCH', '流程网络要求已改变，不会隐式转换或解除');
       if (run.recipe === 'transcribe/v0') {
         const source = readAudioSource(root, run.source.artifactId);
-        candidates = candidates.map(candidate => ({ ...candidate, prepareInput: async ({ signal }) => {
+        candidates = candidates.map(candidate => ({ ...candidate, prepareInput: async ({ signal, taskId, attemptId, networkBudget, recordNetworkRoute, modelRef, providerId }) => {
           const prepared = await prepareProviderInput(candidate.adapter, { model: candidate.providerModel, bytes: source.bytes,
-            filename: source.artifact.id + '.' + AUDIO_TYPES[source.artifact.mediaType], signal });
+            filename: source.artifact.id + '.' + AUDIO_TYPES[source.artifact.mediaType], signal }, { taskId, attemptId, networkBudget, recordNetworkRoute, modelRef, providerId });
           return { audioUrl: prepared.url };
         } }));
       }
       task = claimFlowTask(root, run.id);
       if (!flowStep(run).claimed) run = updateFlowRun(root, run, { [flowStepId(run)]: { ...flowStep(run), claimed: true } });
       signal.throwIfAborted();
-      const normalized = audio ? Object.fromEntries(Object.entries(run.input).filter(([key]) => key !== 'model_ref'))
+      const normalized = audio || video ? Object.fromEntries(Object.entries(run.input).filter(([key]) => key !== 'model_ref'))
         : normalizeGenerationInput('image', run.input).providerInput;
-      task = (await runner.submit({ capability: audio ? AUDIO_RECIPES[run.recipe].capability : 'image', candidates, providerInput: normalized,
+      task = (await runner.submit({ capability: video ? 'video' : audio ? AUDIO_RECIPES[run.recipe].capability : 'image', candidates, providerInput: normalized,
         sourceArtifactId: run.source?.artifactId, flowRunId: run.id })).task;
     } else {
       task = recoverCoreTask(root, task.id);
@@ -150,6 +166,12 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
     signal.throwIfAborted();
     if (task.deliveryState !== 'ready') return facts(root, run);
     if (task.artifactIds.length !== 1) flowFail('IRIS_FLOW_RESULT_UNSUPPORTED', '当前流程只支持一个结果，原 Task 与作品已保留');
+    if (run.recipe === VIDEO_RECIPE) {
+      const metadata = inspectCoreArtifactMetadata(root, task.artifactIds[0]);
+      if (!Object.hasOwn(VIDEO_TYPES, metadata.mediaType) || metadata.size > MAX_VIDEO_BYTES) {
+        flowFail('IRIS_FLOW_RESULT_UNSUPPORTED', '视频首片只交付不超过 32 MiB 的 MP4/WebM；原 Task 与作品已保留');
+      }
+    }
     const output = readCoreArtifactBytes(root, task.artifactIds[0]);
     if (!run.output) run = updateFlowRun(root, run, { output: reference(output.artifact) });
     facts(root, run);
@@ -207,8 +229,8 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
           flowFail('IRIS_FLOW_REVISION_CONFLICT', '流程已改变，请读取当前版本后明确选择');
         }
         facts(dataRoot, run);
-        if (isAudioRecipe(run.recipe)) {
-          if (name === 'flow.select') flowFail('IRIS_FLOW_SELECTION_INVALID', '音频和转写为单一结果，无需选择图片版本');
+        if (isAudioRecipe(run.recipe) || run.recipe === VIDEO_RECIPE) {
+          if (name === 'flow.select') flowFail('IRIS_FLOW_SELECTION_INVALID', '视频、音频和转写为单一结果，无需选择图片版本');
           if (!run.output) flowFail('IRIS_FLOW_NOT_READY', '请先接回原任务的结果');
           return { ...facts(dataRoot, run), export: exportCoreArtifact(dataRoot, run.output.artifactId, input.output_path) };
         }

package/lib/index.js

@@ -262,13 +262,18 @@ export async function apply(ctx) {
     else console.log('[iris] 工作台导入：' + imported.reason);
   });
 
-  // 接管上次进程未跑完的异步任务（恢复循环本身在 tasks.js 里逐任务防御）
-  guard('恢复后台任务', () => {
-    const resumed = tasks.resumePending((t) => {
-      const p = store.providerById(t.providerId);
-      return p ? pollDeps(p, t.cap) : null;
+  // Legacy 接管也要解析当次 DSH 连接；关闭会中止解析，禁止迟到的恢复再启动盯守。
+  void core.runHostOperation(signal => {
+    const resume = () => tasks.resumePending((task) => {
+      const provider = store.providerById(task.providerId);
+      return provider ? taskPollDeps(provider, task) : null;
     });
+    if (!tasks.all().some(task => task.status === 'running' && task.remoteTaskId)) return resume();
+    return withDshProviderConfig(dshHost(ctx), resume, { signal, fresh: true });
+  }).then(resumed => {
     if (resumed.length) console.log(`[iris] 已恢复接管 ${resumed.length} 个后台任务`);
+  }, error => {
+    if (core.snapshot().state === 'open') console.error('[iris] 恢复后台任务失败（已隔离，不影响宿主）:', error?.code || 'unknown');
   });
 
   // Owned background setup lets unload cancel a slow connection resolver during takeover.

package/lib/local-api-projection.js

@@ -1,10 +1,11 @@
 // HTTP DTOs whitelist existing Core facts; never expose records or configuration wholesale.
 import { isAudioRecipe } from './audio-flow-input.js';
+import { VIDEO_RECIPE } from './video-flow-input.js';
 const STATUSES = new Set(['not_started', 'running', 'needs_attention', 'delivery_failed',
   'needs_comparison', 'needs_result', 'awaiting_selection', 'selected', 'ready']);
 
 export function projectLocalApiFlow(facts) {
-  if (facts.contractVersion !== 0 || !['image-edit/v0', 'image-generate/v0'].includes(facts.run.recipe) && !isAudioRecipe(facts.run.recipe) || !STATUSES.has(facts.status)) {
+  if (facts.contractVersion !== 0 || !['image-edit/v0', 'image-generate/v0', VIDEO_RECIPE].includes(facts.run.recipe) && !isAudioRecipe(facts.run.recipe) || !STATUSES.has(facts.status)) {
     throw new TypeError('不支持的流程契约或状态');
   }
   const { run, task } = facts;
@@ -15,10 +16,13 @@ export function projectLocalApiFlow(facts) {
     input: { ...(isAudioRecipe(run.recipe) ? run.recipe === 'speech/v0' ? { text: run.input.text,
       ...(run.input.voice !== undefined ? { voice: run.input.voice } : {}) } : {} : { prompt: run.input.prompt }), modelRef: run.input.model_ref,
       ...(run.input.size !== undefined ? { size: run.input.size } : {}),
+      ...(run.input.duration !== undefined ? { duration: run.input.duration } : {}),
       ...(run.input.workflow_parameters !== undefined ? { workflowParameters: run.input.workflow_parameters } : {}) },
     source: ref(run.source), output: ref(run.output), comparison: ref(run.comparison), selection: ref(run.selection),
     task: task ? { id: task.id, acceptance: task.acceptance, outcome: task.outcome,
-      deliveryState: task.deliveryState, attemptCount: task.attempts.length } : null,
+      deliveryState: task.deliveryState, attemptCount: task.attempts.length,
+      ...(task.networkRoutes ? { networkRoutes: task.networkRoutes.map(route => ({ route: route.route, operation: route.operation, lastAt: route.lastAt,
+        ...(route.poolId ? { poolId: route.poolId } : {}), ...(route.nodeId ? { nodeId: route.nodeId } : {}) })) } : {}) } : null,
     metrics: facts.metrics ? Object.fromEntries(['ratio', 'diffPixels', 'totalPixels', 'width', 'height']
       .map(key => [key, facts.metrics[key]])) : null
   };