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

package/lib/flow-store.js

@@ -4,9 +4,12 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { atomicCreatePrivate, atomicWritePrivate } from './private-storage.js';
-import { WRITER_LEASE_DIR, WRITER_INTENT_FILE } from './core-writer-lease.js';
+import { WRITER_LEASE_DIR, WRITER_INTENT_FILE, isAbandonedWriterPreparation } from './core-writer-lease.js';
 import { normalizeGenerationInput } from './generation-input.js';
 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';
 
 const RUN = /^run_[a-f0-9]{24}$/;
 const TASK = /^task_[a-f0-9]{24}$/;
@@ -14,6 +17,7 @@ const ARTIFACT = /^artifact_[a-f0-9]{24}$/;
 const SHA = /^[a-f0-9]{64}$/;
 const BINDING = /^sha256:[a-f0-9]{64}$/;
 const RECIPE = 'image-edit/v0';
+export const IMAGE_GENERATE_RECIPE = 'image-generate/v0';
 
 export class FlowError extends Error {
   constructor(code, message) { super(message); this.name = 'FlowError'; this.code = code; }
@@ -28,23 +32,81 @@ 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 flowStep = run => run[flowStepId(run)];
+export function requireImageGenerationRoot(root) {
+  if (![2, 3].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) {
+    flowFail('IRIS_FLOW_AUDIO_ROOT_REQUIRED', '音频需要新的专用执行根：execution init --audio；不迁移已有根');
+  }
+}
 
 export function validFlowBinding(value) {
   return keys(value, ['runId', 'stepId', 'inputDigest']) && RUN.test(value.runId)
-    && value.stepId === 'edit' && BINDING.test(value.inputDigest);
+    && ['edit', 'generate', 'speak', 'transcribe'].includes(value.stepId) && BINDING.test(value.inputDigest);
 }
-export function flowTaskBinding(run) { return { runId: run.id, stepId: 'edit', inputDigest: run.inputDigest }; }
+export function flowTaskBinding(run) { return { runId: run.id, stepId: flowStepId(run), inputDigest: run.inputDigest }; }
 
 function inputDigest(run) {
+  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,
+    run.input.model_ref, run.providerBinding, run.input.prompt, run.input.size ?? null, 1,
+    ...(run.input.workflow_parameters !== undefined ? [['comfyui-parameters/v0', normalizeComfyParameters(run.input.workflow_parameters)]] : [])]));
   return 'sha256:' + flowSha256(JSON.stringify([RECIPE, run.source.artifactId, run.source.sha256,
     run.input.model_ref, run.providerBinding, run.input.prompt, run.input.size ?? null, 1]));
 }
 
 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'],
+    ['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)
+      || JSON.stringify(run.input) !== JSON.stringify(normalized)
+      || transcribe && (!reference(run.source) || run.source.artifactId !== run.input.source_artifact_id)
+      || !transcribe && run.source !== undefined
+      || !keys(run[step], ['taskId', 'claimed']) || !TASK.test(run[step].taskId) || typeof run[step].claimed !== 'boolean'
+      || run.inputDigest !== inputDigest(run) || run.output !== undefined && (!reference(run.output) || !run[step].claimed)) {
+    flowFail('IRIS_FLOW_RECORD_INVALID', '音频流程记录结构或绑定摘要冲突');
+  }
+  return run;
+}
+function validateGeneration(run, expectedId, normalized) {
+  if (!keys(run, ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'input', 'providerBinding',
+    'inputDigest', 'generate', 'output', 'selection'],
+  ['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)
+      || !BINDING.test(run.providerBinding) || !parseModelRef(run.input.model_ref)
+      || !keys(run.input, ['prompt', 'model_ref', 'n', 'size', 'workflow_parameters'], ['prompt', 'model_ref', 'n'])
+      || normalized.modelRef !== run.input.model_ref || normalized.sourceArtifactId !== undefined
+      || run.input.prompt !== normalized.providerInput.prompt || run.input.n !== 1
+      || run.input.size !== normalized.providerInput.size
+      || !keys(run.generate, ['taskId', 'claimed']) || !TASK.test(run.generate.taskId) || typeof run.generate.claimed !== 'boolean'
+      || run.inputDigest !== inputDigest(run)
+      || run.output !== undefined && (!reference(run.output) || !run.generate.claimed)
+      || run.selection !== undefined && (!reference(run.selection) || !run.output
+        || run.selection.artifactId !== run.output.artifactId || run.selection.sha256 !== run.output.sha256)) {
+    flowFail('IRIS_FLOW_RECORD_INVALID', '文生图记录结构或绑定摘要冲突');
+  }
+  return run;
+}
 function validate(run, expectedId) {
+  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'],
   ['schemaVersion', 'recipe', 'id', 'revision', 'createdAt', 'updatedAt', 'source', 'input', 'providerBinding', 'inputDigest', 'edit', 'compare'])
@@ -101,7 +163,7 @@ export function inspectFlowRoot(root) {
 export function initializeFlowRoot(root) {
   try { fs.lstatSync(path.join(root, 'flow-store')); return inspectFlowRoot(root); }
   catch (error) { if (error.code !== 'ENOENT') throw error; }
-  if (fs.readdirSync(root).some(name => ![WRITER_LEASE_DIR, WRITER_INTENT_FILE].includes(name))) {
+  if (fs.readdirSync(root).some(name => ![WRITER_LEASE_DIR, WRITER_INTENT_FILE].includes(name) && !isAbandonedWriterPreparation(root, name))) {
     flowFail('IRIS_FLOW_ROOT_NOT_EMPTY', '流程只在新的专用数据根启用；不迁移已有 Task/Artifact 数据根');
   }
   directory(root, 'runs', true);
@@ -122,16 +184,44 @@ export function readFlowRun(root, id) {
     if (error.code === 'ENOENT') flowFail('IRIS_FLOW_NOT_FOUND', '流程记录不存在');
     throw error;
   }
-  return copy(validate(record, id));
+  validate(record, id);
+  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 }) {
+export function prepareFlowCreation({ source, input, providerBinding, recipe }) {
+  if (isAudioRecipe(recipe)) return { 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'),
+    createdAt: new Date().toISOString(), input, providerBinding };
   return { runId: flowId('run'), taskId: flowId('task'), comparisonArtifactId: flowId('artifact'),
     createdAt: new Date().toISOString(), source, input, providerBinding };
 }
 
 export function validateFlowCreation(intent) {
+  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,
+      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);
+    return validate(record, record.id);
+  }
+  if (intent?.recipe === IMAGE_GENERATE_RECIPE) {
+    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,
+      createdAt: intent.createdAt, updatedAt: intent.createdAt, input: intent.input,
+      providerBinding: intent.providerBinding, generate: { taskId: intent.taskId, claimed: false } };
+    record.inputDigest = inputDigest(record);
+    return validate(record, record.id);
+  }
   if (!keys(intent, ['runId', 'taskId', 'comparisonArtifactId', 'createdAt', 'source', 'input', 'providerBinding'])) {
     flowFail('IRIS_FLOW_RECORD_INVALID', '流程创建意图无效');
   }
@@ -146,12 +236,15 @@ export function validateFlowCreation(intent) {
 export function commitFlowCreation(root, intent, { allowCreate = true } = {}) {
   inspectFlowRoot(root);
   const record = validateFlowCreation(intent);
+  if (isAudioRecipe(record.recipe)) requireAudioRoot(root);
+  if (record.recipe === IMAGE_GENERATE_RECIPE) requireImageGenerationRoot(root);
   let current;
   try { current = readFlowRun(root, record.id); }
   catch (error) { if (error.code !== 'IRIS_FLOW_NOT_FOUND') throw error; }
   if (current) {
     if (current.createdAt !== record.createdAt || current.inputDigest !== record.inputDigest
-        || current.edit.taskId !== record.edit.taskId || current.compare.artifactId !== record.compare.artifactId) {
+        || current.recipe !== record.recipe || flowStep(current).taskId !== flowStep(record).taskId
+        || current.compare?.artifactId !== record.compare?.artifactId) {
       flowFail('IRIS_FLOW_INPUT_CONFLICT', '原流程与预留创建身份不一致');
     }
     return current;
@@ -168,7 +261,9 @@ 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', '流程在本次操作期间已改变');
-  if (!keys(patch, ['edit', 'output', 'comparison', 'selection'], [])) throw new TypeError('未知流程更新字段');
+  const allowed = isAudioRecipe(current.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() };
   validate(record, current.id);
   atomicWritePrivate(recordFile(root, record.id), JSON.stringify(record, null, 2) + '\n');
@@ -190,6 +285,6 @@ export function listFlowRuns(root) {
 export function flowReferences(root) {
   try { fs.lstatSync(path.join(root, 'flow-store')); }
   catch (error) { if (error.code === 'ENOENT') return []; throw error; }
-  return listFlowRuns(root).map(run => ({ run, taskIds: [run.edit.taskId],
-    artifactIds: [...new Set([run.source.artifactId, run.compare.artifactId, run.output?.artifactId, run.selection?.artifactId].filter(Boolean))] }));
+  return listFlowRuns(root).map(run => ({ run, taskIds: [flowStep(run).taskId],
+    artifactIds: [...new Set([run.source?.artifactId, run.compare?.artifactId, run.output?.artifactId, run.selection?.artifactId].filter(Boolean))] }));
 }

package/lib/generation-input.js

@@ -3,9 +3,10 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { normalizeMusicOptions } from './music-options.js';
+import { normalizeComfyParameters } from './comfyui-workflow.js';
 
 const FIELDS = Object.freeze({
-  image: ['prompt', 'size', 'n', 'source_artifact_id'],
+  image: ['prompt', 'size', 'n', 'source_artifact_id', 'workflow_parameters'],
   video: ['prompt', 'size', 'duration', 'img_data_url', 'first_frame_path', 'audio_path', 'resolution'],
   tts: ['text', 'voice'],
   music: ['prompt', 'timeout_ms', 'retry_502', 'retry_delay_ms'],
@@ -86,6 +87,14 @@ export function normalizeGenerationInput(capability, input, { allowAudioPath = f
     const n = input.n === undefined ? 1 : Number(input.n);
     if (!Number.isSafeInteger(n) || n < 1 || n > 4) fail('n 必须为 1–4 的整数');
     providerInput.n = n;
+    if (input.workflow_parameters !== undefined) {
+      if (!modelRef || sourceArtifactId || n !== 1) fail('工作流参数需要明确 model_ref、n=1 且不带来源图片');
+      try { providerInput.workflow_parameters = Object.freeze(normalizeComfyParameters(input.workflow_parameters)); }
+      catch (error) { fail(error.message); }
+      if (Buffer.byteLength(JSON.stringify({ model_ref: modelRef, ...providerInput }, null, 2)) > 96 * 1024) {
+        fail('参数化流程输入最多 96 KiB；请缩短提示词或参数值');
+      }
+    }
   }
   if (capability === 'video') {
     if (input.duration !== undefined) {

package/lib/headless-vision.js

@@ -70,10 +70,10 @@ function completionResult(completion, routes) {
   return { ...result, ...selectedModel(completion, routes) };
 }
 
-async function transcribeVideo({ catalog, input, runtime, operation, onRateLimit, onModelAvailability }) {
-  const routes = transcribeCandidatesFromCatalog(catalog, input.transcribe_model_ref);
-  const candidates = routes.map(route => ({ adapter: createConfiguredProviderAdapter(route.provider, { onRateLimit, onModelAvailability }),
-    model: route.modelRef, selectionReason: route.selectionReason, providerBinding: providerTaskBinding(route.provider) }));
+async function transcribeVideo({ catalog, input, runtime, operation, onRateLimit, onModelAvailability, registry }) {
+  const routes = transcribeCandidatesFromCatalog(catalog, input.transcribe_model_ref, registry);
+  const candidates = routes.map(route => ({ adapter: createConfiguredProviderAdapter(route.provider, { onRateLimit, onModelAvailability, registry }),
+    model: route.modelRef, selectionReason: route.selectionReason, providerBinding: providerTaskBinding(route.provider, registry) }));
   const audio = await waitForModelWork(() => extractAudioTrack({ inputPath: input.video_path, signal: operation.signal }), operation.signal);
   const abortRuntime = () => { void runtime.dispose().catch(() => {}); };
   operation.signal.addEventListener('abort', abortRuntime, { once: true });
@@ -87,7 +87,7 @@ async function transcribeVideo({ catalog, input, runtime, operation, onRateLimit
       providerInput: { audioUrl: prepared.url } }), operation.signal, 'invoke', 'unknown');
     task = submitted.task;
     if (task.acceptance === 'accepted' && task.outcome === 'none') {
-      const adapter = createConfiguredProviderAdapter(providerForTaskFromCatalog(catalog, task), { onRateLimit,
+      const adapter = createConfiguredProviderAdapter(providerForTaskFromCatalog(catalog, task, registry), { onRateLimit, registry,
         modelId: routes.find(route => route.modelRef === task.modelRef)?.model });
       while (task.outcome === 'none') {
         task = await waitForModelWork(() => runner.observe(task.id, adapter), operation.signal, 'read', 'responded');
@@ -111,7 +111,7 @@ async function transcribeVideo({ catalog, input, runtime, operation, onRateLimit
   }
 }
 
-export async function executeVisionCommand({ command, input, catalog, modelRef = '', runtime, signal, timeoutMs = VISION_BUDGET.timeoutMs, onRateLimit, onModelAvailability }) {
+export async function executeVisionCommand({ command, input, catalog, modelRef = '', runtime, signal, timeoutMs = VISION_BUDGET.timeoutMs, onRateLimit, onModelAvailability, registry }) {
   normalizeVisionInput(command, input);
   if (modelRef && !/^[^:]+::.+$/.test(modelRef)) invalid('--model-ref 必须是 providerId::modelId');
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > VISION_BUDGET.timeoutMs) invalid('--timeout-ms 必须是 1–120000 的整数');
@@ -140,7 +140,7 @@ export async function executeVisionCommand({ command, input, catalog, modelRef =
       }
       let transcript = input.transcribe_text || '', transcription = { status: transcript.trim() ? 'provided' : 'disabled' };
       if (input.transcribe) {
-        const asr = meta.hasAudio ? await transcribeVideo({ catalog, input, runtime, operation, onRateLimit, onModelAvailability }) : { report: { status: 'no_audio' }, text: '' };
+        const asr = meta.hasAudio ? await transcribeVideo({ catalog, input, runtime, operation, onRateLimit, onModelAvailability, registry }) : { report: { status: 'no_audio' }, text: '' };
         transcript = asr.text; transcription = asr.report;
       }
       const completion = await summarizeMedia({ ports, frames, question: input.question, transcript, operation, budget });

package/lib/image-edit-input.js

@@ -10,7 +10,7 @@ function invalid(message) {
 }
 
 export function imageEditCandidates(candidates) {
-  const supported = candidate => supportsImageEdit(candidate.adapter.protocol, candidate.providerModel);
+  const supported = candidate => candidate.supportsImageEdit ?? supportsImageEdit(candidate.adapter.protocol, candidate.providerModel);
   if (candidates.some(candidate => candidate.selectionReason === 'explicit'
       && !supported(candidate))) {
     throw invalid('指定模型的图片协议不支持此类改图，请选择聊天生图模型或 DashScope Qwen 原生改图模型');

package/lib/image-flow.js

@@ -8,7 +8,10 @@ import { imageEditCandidates, readImageEditArtifact } from './image-edit-input.j
 import { parseModelRef } from './models.js';
 import { pixelDiff } from './pixels.js';
 import { createProviderTaskRunner } from './provider-task-runner.js';
-import { commitFlowCreation, flowFail, flowSha256, initializeFlowRoot, inspectFlowRoot, listFlowRuns, prepareFlowCreation, readFlowRun, updateFlowRun } from './flow-store.js';
+import { prepareProviderInput } from './provider-adapter.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';
 
 function exact(input, allowed) {
   if (!input || typeof input !== 'object' || Array.isArray(input) || Object.keys(input).some(key => !allowed.includes(key))) {
@@ -24,14 +27,15 @@ function readReference(root, expected) {
 }
 
 function facts(root, run) {
-  const source = readReference(root, run.source);
+  const source = run.source ? readReference(root, run.source) : null;
   const task = findFlowTask(root, run);
   if (run.output) {
     if (task.deliveryState !== 'ready' || task.artifactIds.length !== 1 || task.artifactIds[0] !== run.output.artifactId) {
       flowFail('IRIS_FLOW_TASK_CONFLICT', '流程输出与原 Task 的交付事实不一致');
     }
     const { artifact } = readReference(root, run.output);
-    if (artifact.metadata.taskId !== task.id || !artifact.relations.some(edge => edge.type === 'derived-from' && edge.artifactId === source.artifact.id)) {
+    if (artifact.metadata.taskId !== task.id || source && !artifact.relations.some(edge => edge.type === 'derived-from' && edge.artifactId === source.artifact.id)
+        || !source && artifact.relations.length) {
       flowFail('IRIS_FLOW_ARTIFACT_CONFLICT', '流程输出缺少原 Task 或来源关系');
     }
   }
@@ -45,35 +49,53 @@ 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 = run.comparison ? run.selection ? 'selected' : 'awaiting_selection' : 'needs_comparison';
+  else if (task?.deliveryState === 'ready') status = isAudioRecipe(run.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';
   else if (task?.attempts.length) status = task.acceptance === 'accepted' ? 'running' : 'needs_attention';
   return { contractVersion: 0, run, task, status, ...(comparison ? { metrics: comparison.metadata } : {}) };
 }
 
-/** Internal fixed recipe. All state/leases belong to the supplied operation-scoped runtime. */
-export function createImageFlowService(runtime, { resolveImageCandidates, resolveTaskAdapter } = {}) {
+/** Fixed image/audio recipes, sharing operation-scoped leases and the original Task. */
+export function createImageFlowService(runtime, { resolveImageCandidates, resolveAudioCandidates, resolveTaskAdapter } = {}) {
   function creationInput(input) {
+    if (isAudioRecipe(input?.recipe)) {
+      const { recipe, ...value } = input;
+      return { recipe, ...normalizeAudioFlowInput(recipe, value) };
+    }
     const normalized = normalizeGenerationInput('image', input);
-    if (!normalized.sourceArtifactId || !parseModelRef(normalized.modelRef) || normalized.providerInput.n !== 1) {
-      flowFail('IRIS_FLOW_INPUT_INVALID', '首版流程需要来源 Artifact、明确 model_ref 和 n=1');
+    if (!parseModelRef(normalized.modelRef) || normalized.providerInput.n !== 1) {
+      flowFail('IRIS_FLOW_INPUT_INVALID', '图片流程需要明确 model_ref 和 n=1；改图还需来源 Artifact');
     }
     return { prompt: normalized.providerInput.prompt, model_ref: normalized.modelRef,
-      source_artifact_id: normalized.sourceArtifactId, n: 1,
-      ...(normalized.providerInput.size !== undefined ? { size: normalized.providerInput.size } : {}) };
+      ...(normalized.sourceArtifactId ? { source_artifact_id: normalized.sourceArtifactId } : {}), n: 1,
+      ...(normalized.providerInput.size !== undefined ? { size: normalized.providerInput.size } : {}),
+      ...(normalized.providerInput.workflow_parameters !== undefined ? { workflow_parameters: normalized.providerInput.workflow_parameters } : {}) };
   }
   async function prepareCreation(root, signal, input) {
     const owned = creationInput(input);
     inspectFlowRoot(root);
-    const source = await readImageEditArtifact(root, owned.source_artifact_id, signal);
+    const audio = isAudioRecipe(owned.recipe);
+    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);
-    return prepareFlowCreation({ source: { artifactId: owned.source_artifact_id, sha256: flowSha256(source.bytes) },
-      input: owned, providerBinding: candidates[0].providerBinding });
+    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 } : {}) });
+  }
+  function readAudioSource(root, id) {
+    const source = readCoreArtifactBytes(root, id);
+    readImportAudio(source.bytes, source.artifact.mediaType);
+    return source;
   }
   async function candidatesFor(runInput, signal, binding) {
-    if (!resolveImageCandidates) flowFail('IRIS_FLOW_PROVIDER_REQUIRED', '创建或首次提交流程需要显式 Provider 配置');
+    const audio = isAudioRecipe(runInput.recipe), resolver = audio ? resolveAudioCandidates : resolveImageCandidates;
+    if (!resolver) flowFail('IRIS_FLOW_PROVIDER_REQUIRED', '创建或首次提交流程需要显式 Provider 配置');
     signal.throwIfAborted();
-    const candidates = await resolveImageCandidates({ modelRef: runInput.model_ref, signal });
+    const candidates = await resolver({ modelRef: runInput.model_ref, signal, input: runInput,
+      ...(audio ? { capability: AUDIO_RECIPES[runInput.recipe].capability } : {}) });
     signal.throwIfAborted();
     const parsed = parseModelRef(runInput.model_ref);
     if (!Array.isArray(candidates) || candidates.length !== 1 || candidates[0].model !== runInput.model_ref
@@ -81,7 +103,8 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
       flowFail('IRIS_FLOW_INPUT_CONFLICT', '流程必须绑定单一明确模型和有效的连接摘要');
     }
     if (binding !== undefined && candidates[0].providerBinding !== binding) flowFail('IRIS_FLOW_PROVIDER_CHANGED', '连接或协议已改变；原流程不重新绑定或生成');
-    return imageEditCandidates([{ ...candidates[0], providerModel: parsed.modelId, selectionReason: 'explicit' }]);
+    const resolved = [{ ...candidates[0], providerModel: parsed.modelId, selectionReason: 'explicit' }];
+    return runInput.source_artifact_id && !audio ? imageEditCandidates(resolved) : resolved;
   }
 
   async function adapterFor(task, signal) {
@@ -94,16 +117,26 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
   async function continueRun(root, signal, id) {
     let run = readFlowRun(root, id);
     let task = facts(root, run).task;
-    if (task?.attempts.length && !run.edit.claimed) flowFail('IRIS_FLOW_TASK_CONFLICT', '步骤检查点与已开始的 Task 冲突');
+    if (task?.attempts.length && !flowStep(run).claimed) flowFail('IRIS_FLOW_TASK_CONFLICT', '步骤检查点与已开始的 Task 冲突');
     const runner = createProviderTaskRunner(runtime);
     if (!task || !task.attempts.length) {
-      const candidates = await candidatesFor(run.input, signal, run.providerBinding);
+      const audio = isAudioRecipe(run.recipe);
+      let candidates = await candidatesFor({ ...run.input, ...(audio ? { recipe: run.recipe } : {}) }, signal, run.providerBinding);
+      if (run.recipe === 'transcribe/v0') {
+        const source = readAudioSource(root, run.source.artifactId);
+        candidates = candidates.map(candidate => ({ ...candidate, prepareInput: async ({ signal }) => {
+          const prepared = await prepareProviderInput(candidate.adapter, { model: candidate.providerModel, bytes: source.bytes,
+            filename: source.artifact.id + '.' + AUDIO_TYPES[source.artifact.mediaType], signal });
+          return { audioUrl: prepared.url };
+        } }));
+      }
       task = claimFlowTask(root, run.id);
-      if (!run.edit.claimed) run = updateFlowRun(root, run, { edit: { ...run.edit, claimed: true } });
+      if (!flowStep(run).claimed) run = updateFlowRun(root, run, { [flowStepId(run)]: { ...flowStep(run), claimed: true } });
       signal.throwIfAborted();
-      const normalized = normalizeGenerationInput('image', run.input);
-      task = (await runner.submit({ capability: 'image', candidates, providerInput: normalized.providerInput,
-        sourceArtifactId: run.source.artifactId, flowRunId: run.id })).task;
+      const normalized = audio ? 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,
+        sourceArtifactId: run.source?.artifactId, flowRunId: run.id })).task;
     } else {
       task = recoverCoreTask(root, task.id);
       assertFlowTaskMatches(task, run);
@@ -116,11 +149,11 @@ 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 (task.artifactIds.length !== 1) flowFail('IRIS_FLOW_RESULT_UNSUPPORTED', '当前流程只支持一个结果，原 Task 与作品已保留');
     const output = readCoreArtifactBytes(root, task.artifactIds[0]);
     if (!run.output) run = updateFlowRun(root, run, { output: reference(output.artifact) });
     facts(root, run);
-    if (!run.comparison) {
+    if (run.source && !run.comparison && !isAudioRecipe(run.recipe)) {
       const source = readReference(root, run.source);
       const diff = await pixelDiff({ inputA: source.bytes, inputB: output.bytes, grid: 8, topRegions: 3 });
       signal.throwIfAborted();
@@ -152,7 +185,7 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
       return runtime.run('inspect', ({ dataRoot }) => {
         const runs = listFlowRuns(dataRoot);
         return { contractVersion: 0, total: runs.length, runs: runs.map(run => ({ id: run.id, recipe: run.recipe,
-          createdAt: run.createdAt, source: run.source, modelRef: run.input.model_ref, taskId: run.edit.taskId })) };
+          createdAt: run.createdAt, ...(run.source ? { source: run.source } : {}), modelRef: run.input.model_ref, taskId: flowStep(run).taskId })) };
       });
     }
     if (name === 'flow.inspect') {
@@ -164,13 +197,24 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
       return runtime.run('execute', ({ dataRoot, signal }) => continueRun(dataRoot, signal, input.run_id));
     }
     if (name === 'flow.select' || name === 'flow.export') {
-      exact(input, name === 'flow.select' ? ['run_id', 'artifact_id'] : ['run_id', 'output_path']);
+      exact(input, name === 'flow.select' ? ['run_id', 'artifact_id', 'expected_revision'] : ['run_id', 'output_path']);
+      if (input.expected_revision !== undefined && (!Number.isSafeInteger(input.expected_revision) || input.expected_revision < 1)) {
+        flowFail('IRIS_FLOW_INPUT_INVALID', '预期流程版本必须是正整数');
+      }
       return runtime.run('execute', ({ dataRoot }) => {
         let run = readFlowRun(dataRoot, input.run_id);
+        if (input.expected_revision !== undefined && run.revision !== input.expected_revision) {
+          flowFail('IRIS_FLOW_REVISION_CONFLICT', '流程已改变，请读取当前版本后明确选择');
+        }
         facts(dataRoot, run);
-        if (!run.comparison) flowFail('IRIS_FLOW_NOT_READY', '请先完成改图与比较，再选择结果');
+        if (isAudioRecipe(run.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) };
+        }
+        if (!run.output || run.source && !run.comparison) flowFail('IRIS_FLOW_NOT_READY', '请先保存生成结果；改图还需完成比较');
         if (name === 'flow.select') {
-          const selected = [run.source, run.output].find(item => item.artifactId === input.artifact_id);
+          const selected = [run.source, run.output].filter(Boolean).find(item => item.artifactId === input.artifact_id);
           if (!selected) flowFail('IRIS_FLOW_SELECTION_INVALID', '只能选择本流程的原图或新版');
           if (run.selection?.artifactId !== selected.artifactId) run = updateFlowRun(dataRoot, run, { selection: selected });
           return facts(dataRoot, run);
@@ -182,7 +226,7 @@ export function createImageFlowService(runtime, { resolveImageCandidates, resolv
     throw new TypeError('未知的内部 Flow 命令');
   }
   return Object.freeze({ execute, prepareCreation, inspectCreation: (root, intent, options) => {
-    readReference(root, intent.source);
+    if (intent.source) readReference(root, intent.source);
     return facts(root, commitFlowCreation(root, intent, options));
   } });
 }

package/lib/index.js

@@ -66,38 +66,47 @@ function outputDir() {
 
 /* ---------------- 媒体路由：/iris/media/:taskId/:token/:name ---------------- */
 
+let latestNativeRuntime;
 function mountIrisRoutes(routeCtx, core, routes) {
   // Cordis 服务只在 DSH 宿主边界探测；Command 与通用工具辅助函数不接收原始 ctx
   const host = dshHost(routeCtx);
   const reg = hasHostPort(host, 'routes') ? host.ports.routes : undefined;
   if (!reg || typeof reg.register !== 'function' || routes.mounted) return;
+  const disposers = []; let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    const errors = [];
+    for (const dispose of disposers.reverse()) { try { if (typeof dispose === 'function') dispose(); } catch (error) { errors.push(error); } }
+    if (routes.mounted && latestNativeRuntime === core) closeAllSse();
+    routes.mounted = false;
+    if (errors.length) throw new AggregateError(errors, 'Iris 路由释放失败');
+  };
   try {
     const disposeMedia = reg.register({
       kind: 'prefix',
       path: '/iris/media',
       handler: guarded(serveMedia)
     });
+    disposers.push(disposeMedia);
     const disposeApi = reg.register({
       kind: 'prefix',
       path: '/iris/api',
       handler: guarded((req, res) => serveApi(req, res, dshHost(routeCtx), core))
     });
+    disposers.push(disposeApi);
     const disposeRender = reg.register({
       kind: 'prefix',
       path: '/iris/render',
       handler: guarded(serveRender)
     });
+    disposers.push(disposeRender);
+    routeCtx.effect(() => release, 'iris: media+api+actions+render routes');
     routes.mounted = true;
     recordHostRoutes(EXPECTED_IRIS_ROUTES);
-    routeCtx.effect(() => () => {
-      if (typeof disposeMedia === 'function') disposeMedia();
-      if (typeof disposeApi === 'function') disposeApi();
-      if (typeof disposeRender === 'function') disposeRender();
-      closeAllSse(); // SSE 长连接随插件停用一起关闭，不留悬挂连接
-      routes.mounted = false;
-    }, 'iris: media+api+actions+render routes');
     console.log('[iris] 媒体+工作台+操作路由已挂载：/iris/media · /iris/api · /iris/api/actions · /iris/render');
   } catch (err) {
+    try { release(); } catch (cleanup) { console.error('[iris] 路由回滚失败：', cleanup.message); }
     console.error('[iris] 路由挂载失败：', err && err.message);
   }
 }
@@ -221,13 +230,24 @@ function safeRegister(host, definition) {
 export async function apply(ctx) {
   beginHostRuntime({ pluginId: IRIS_PLUGIN_ID, version: PACKAGE_VERSION });
   const core = createDshRuntime({ dataRoot: dshCoreDataRoot(), getHost: () => dshHost(ctx) });
+  latestNativeRuntime = core;
   ctx.provide('irisRuntime', core);
   const routes = { mounted: false };
   const { cropForDsh, diffForDsh, framesForDsh, summaryFramesForDsh, visionImageForDsh, htmlForDsh, inspectProviderTaskForDsh, projectCoreTaskForDsh, readCoreArtifactMediaForDsh, resumeProviderTaskWatchesForDsh } = core;
   ctx.effect(() => () => {
-    tasks.stopWatchAll();
+    if (latestNativeRuntime === core) tasks.stopWatchAll();
     return core.dispose();
   }, 'iris: DSH runtime');
+  // Explicit additional connection for shared Flow tools. Legacy native media/skills/UI retain their own roots.
+  if (process.env.IRIS_CORE_CONNECTION_FILE) {
+    const { createDshServiceBridge } = await import('./dsh-service-bridge.js');
+    const bridge = createDshServiceBridge({ connectionFile: process.env.IRIS_CORE_CONNECTION_FILE,
+      requestedScopes: (process.env.IRIS_CORE_SCOPES || 'read').split(','), getHost: () => dshHost(ctx), harnessVersion: dshHost(ctx).version });
+    ctx.provide('irisCoreService', bridge);
+    ctx.effect(() => () => bridge.dispose(), 'iris: Core service connection');
+    try { await bridge.start(); }
+    catch (error) { console.error('[iris] Core 服务连接失败:', error?.code || 'IRIS_CORE_SERVICE_UNAVAILABLE'); }
+  }
   guard('Iris 私有存储权限收紧', () => hardenPrivateTree(store.irisHome()));
 
   guard('上传临时文件清理', () => purgeStaleUploads());
@@ -399,7 +419,7 @@ export async function apply(ctx) {
       const refs = [];
       for (const f of files) {
         const mediaType = MEDIA_TYPES[path.extname(f).toLowerCase()] || 'image/png';
-        const ref = await attachmentService(host).saveImage({ data: new Uint8Array(fs.readFileSync(f)), mediaType, name: path.basename(f) });
+        const ref = await attachmentService(dshHost(ctx)).saveImage({ data: new Uint8Array(fs.readFileSync(f)), mediaType, name: path.basename(f) });
         refs.push(ref);
         blocks.push({ type: 'image', attachment: ref });
       }
@@ -647,7 +667,7 @@ export async function apply(ctx) {
       const refs = [];
       for (let i = 0; i < frames.length; i++) {
         const f = frames[i];
-        const ref = await attachmentService(host).saveImage({
+        const ref = await attachmentService(dshHost(ctx)).saveImage({
           data: new Uint8Array(f.bytes),
           mediaType,
           name: `iris-frame-${Date.now()}-${i + 1}.${ext}`
@@ -744,7 +764,7 @@ export async function apply(ctx) {
       });
       // 成功摘要的同一张拼图作为显式工具产物发布。
       if (exec.signal?.aborted) throw exec.signal.reason;
-      const ref = await attachmentService(host).saveImage({
+      const ref = await attachmentService(dshHost(ctx)).saveImage({
         data: new Uint8Array(sheet.buffer),
         mediaType: 'image/png',
         name: `iris-sheet-${Date.now()}.png`
@@ -801,7 +821,7 @@ export async function apply(ctx) {
         async prepareImage(signal) {
           if (source === 'artifact_id') return visionImageForDsh({ artifactId: args.artifact_id, signal });
           const image = await readVisionImageFile(p, mt, signal);
-          await waitForModelWork(() => attachmentService(host).saveImage({ data: image.bytes, mediaType: mt, name: path.basename(p) }), signal);
+          await waitForModelWork(() => attachmentService(dshHost(ctx)).saveImage({ data: image.bytes, mediaType: mt, name: path.basename(p) }), signal);
           return image;
         }
       });
@@ -833,10 +853,10 @@ export async function apply(ctx) {
       return runVisionTool(dshHost(ctx), exec, { origin: 'relook', model: args.model, question,
         async prepareImage(signal) {
           // 会话扫描、解引用与读图都属于这次操作的总预算。
-          const hit = (await waitForModelWork(() => sessionAttachmentRef(host, exec, id), signal)) || findOwnAttachment(id);
+          const hit = (await waitForModelWork(() => sessionAttachmentRef(dshHost(ctx), exec, id), signal)) || findOwnAttachment(id);
           if (!hit) throw new Error('iris: 图片引用不可用');
           if (hit.absPath) return readVisionImageFile(hit.absPath, hit.ref.mediaType || MEDIA_TYPES[path.extname(hit.absPath).toLowerCase()] || 'image/png', signal);
-          const stored = await waitForModelWork(() => attachmentService(host).readImage(hit.ref, signal), signal);
+          const stored = await waitForModelWork(() => attachmentService(dshHost(ctx)).readImage(hit.ref, signal), signal);
           return { bytes: new Uint8Array(stored.data), mediaType: stored.mediaType || hit.ref.mediaType };
         }
       });
@@ -900,7 +920,7 @@ export async function apply(ctx) {
         signal: exec.signal
       });
       if (exec.signal && exec.signal.aborted) throw new Error('已取消');
-      const ref = await attachmentService(host).saveImage({
+      const ref = await attachmentService(dshHost(ctx)).saveImage({
         data: new Uint8Array(result.bytes),
         mediaType: result.mediaType,
         name: `iris-crop-${Date.now()}.png`
@@ -946,7 +966,7 @@ export async function apply(ctx) {
         grid: args.grid, topRegions: args.top_regions, signal: exec.signal
       });
       const { ratio, diffPixels, totalPixels, width, height, worstRegions } = result.metrics;
-      const ref = await attachmentService(host).saveImage({
+      const ref = await attachmentService(dshHost(ctx)).saveImage({
         data: new Uint8Array(result.bytes),
         mediaType: result.mediaType,
         name: `iris-diff-${Date.now()}.png`
@@ -1037,7 +1057,7 @@ export async function apply(ctx) {
       });
       const png = Buffer.from(rendered.bytes);
       const { width: outW, height: outH } = await imageDimensions(png);
-      const ref = await attachmentService(host).saveImage({
+      const ref = await attachmentService(dshHost(ctx)).saveImage({
         data: new Uint8Array(png),
         mediaType: 'image/png',
         name: `iris-html-${Date.now()}.png`