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

package/lib/image-flow.js

@@ -1,14 +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 { commitFlowCreation, flowFail, flowSha256, initializeFlowRoot, inspectFlowRoot, listFlowRuns, prepareFlowCreation, readFlowRun, updateFlowRun } from './flow-store.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, 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))) {
@@ -24,14 +30,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 +52,62 @@ 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.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';
   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 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) };
+    }
     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);
+    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);
-    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 || 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);
+    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), 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 resolveImageCandidates({ modelRef: runInput.model_ref, signal });
+    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
@@ -81,12 +115,14 @@ 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) {
     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;
   }
@@ -94,16 +130,29 @@ 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) runner.assertIdle(task.id);
     if (!task || !task.attempts.length) {
-      const candidates = await candidatesFor(run.input, signal, run.providerBinding);
+      const audio = isAudioRecipe(run.recipe);
+      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, 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 }, { taskId, attemptId, networkBudget, recordNetworkRoute, modelRef, providerId });
+          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 || video ? Object.fromEntries(Object.entries(run.input).filter(([key]) => key !== 'model_ref'))
+        : normalizeGenerationInput('image', run.input).providerInput;
+      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);
       assertFlowTaskMatches(task, run);
@@ -116,11 +165,17 @@ 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 与作品已保留');
+    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);
-    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 +207,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 +219,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) || 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) };
+        }
+        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 +248,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());
@@ -242,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.
@@ -399,7 +424,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 +672,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 +769,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 +826,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 +858,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 +925,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 +971,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 +1062,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`

package/lib/local-api-projection.js

@@ -1,9 +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', 'awaiting_selection', 'selected']);
+  'needs_comparison', 'needs_result', 'awaiting_selection', 'selected', 'ready']);
 
 export function projectLocalApiFlow(facts) {
-  if (facts.contractVersion !== 0 || facts.run.recipe !== 'image-edit/v0' || !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;
@@ -11,11 +13,16 @@ export function projectLocalApiFlow(facts) {
   return {
     contractVersion: 0, id: run.id, recipe: run.recipe, revision: run.revision,
     createdAt: run.createdAt, updatedAt: run.updatedAt, status: facts.status,
-    input: { prompt: run.input.prompt, modelRef: run.input.model_ref,
-      ...(run.input.size !== undefined ? { size: run.input.size } : {}) },
+    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
   };
@@ -23,5 +30,7 @@ export function projectLocalApiFlow(facts) {
 
 export function projectLocalApiRunSummary(run) {
   return { id: run.id, recipe: run.recipe, createdAt: run.createdAt,
-    modelRef: run.modelRef, source: { artifactId: run.source.artifactId } };
+    updatedAt: run.updatedAt, revision: run.revision, modelRef: run.input.model_ref,
+    source: run.source ? { artifactId: run.source.artifactId } : null, output: run.output ? { artifactId: run.output.artifactId } : null,
+    selection: run.selection ? { artifactId: run.selection.artifactId } : null };
 }

package/lib/local-api-token-directory.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { writeLocalApiTokenFile } from './local-api.js';
+
+const invalid = message => { throw Object.assign(new Error(message), { code: 'IRIS_API_TOKEN_DIRECTORY_INVALID' }); };
+
+/** The explicitly chosen directory may be new; its parent must exist. No chmod or cleanup. */
+export function checkLocalApiTokenDirectory(directory, dataRoot) {
+  if (typeof directory !== 'string' || !path.isAbsolute(directory)) invalid('token-dir 必须是根外私有目录的绝对路径');
+  const supplied = path.resolve(directory);
+  let info;
+  try { info = fs.lstatSync(supplied); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  if (info && (!info.isDirectory() || info.isSymbolicLink() || process.platform !== 'win32' && info.mode & 0o077)) {
+    invalid('token-dir 必须是私有真实目录（POSIX 0700）；不会修改已有目录权限');
+  }
+  const resolved = info ? fs.realpathSync(supplied) : path.join(fs.realpathSync(path.dirname(supplied)), path.basename(supplied));
+  const physical = info ? fs.realpathSync.native(supplied) : path.join(fs.realpathSync.native(path.dirname(supplied)), path.basename(supplied));
+  const relative = path.relative(fs.realpathSync.native(dataRoot), physical);
+  if (!relative || relative !== '..' && !relative.startsWith('..' + path.sep) && !path.isAbsolute(relative)) invalid('token-dir 必须位于 Core 数据根之外');
+  return resolved;
+}
+
+export function writeLocalApiTokenDirectory(directory, token, dataRoot) {
+  const target = checkLocalApiTokenDirectory(directory, dataRoot);
+  if (!fs.existsSync(target)) fs.mkdirSync(target, { mode: 0o700 });
+  const file = path.join(target, 'session-' + crypto.randomUUID() + '.token');
+  writeLocalApiTokenFile(file, token, dataRoot);
+  return file;
+}