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

package/lib/image-flow.js

@@ -0,0 +1,232 @@
+'use strict';
+
+import { createCoreArtifact, exportCoreArtifact, 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 { 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 { 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))) {
+    flowFail('IRIS_FLOW_INPUT_INVALID', '流程输入包含不支持的字段');
+  }
+}
+const reference = artifact => ({ artifactId: artifact.id, sha256: artifact.digest.value });
+
+function readReference(root, expected) {
+  const value = readCoreArtifactBytes(root, expected.artifactId);
+  if (value.artifact.digest.value !== expected.sha256) flowFail('IRIS_FLOW_ARTIFACT_CONFLICT', '流程引用的作品摘要已改变');
+  return value;
+}
+
+function facts(root, run) {
+  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 || source && !artifact.relations.some(edge => edge.type === 'derived-from' && edge.artifactId === source.artifact.id)
+        || !source && artifact.relations.length) {
+      flowFail('IRIS_FLOW_ARTIFACT_CONFLICT', '流程输出缺少原 Task 或来源关系');
+    }
+  }
+  let comparison;
+  if (run.comparison) {
+    comparison = readReference(root, run.comparison).artifact;
+    if (comparison.kind !== 'pixel-diff' || comparison.relations.length !== 2
+        || ![run.source.artifactId, run.output.artifactId].every(id => comparison.relations.some(edge => edge.type === 'derived-from' && edge.artifactId === id))) {
+      flowFail('IRIS_FLOW_ARTIFACT_CONFLICT', '比较作品与流程来源不一致');
+    }
+  }
+  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'
+    : 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 } : {}) };
+}
+
+/** 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 (!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,
+      ...(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 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);
+    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) {
+    const audio = isAudioRecipe(runInput.recipe), resolver = audio ? resolveAudioCandidates : resolveImageCandidates;
+    if (!resolver) flowFail('IRIS_FLOW_PROVIDER_REQUIRED', '创建或首次提交流程需要显式 Provider 配置');
+    signal.throwIfAborted();
+    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
+        || candidates[0].adapter?.id !== parsed.providerId || !/^sha256:[a-f0-9]{64}$/.test(candidates[0].providerBinding)) {
+      flowFail('IRIS_FLOW_INPUT_CONFLICT', '流程必须绑定单一明确模型和有效的连接摘要');
+    }
+    if (binding !== undefined && candidates[0].providerBinding !== binding) flowFail('IRIS_FLOW_PROVIDER_CHANGED', '连接或协议已改变；原流程不重新绑定或生成');
+    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 });
+    signal.throwIfAborted();
+    return adapter;
+  }
+
+  async function continueRun(root, signal, id) {
+    let run = readFlowRun(root, id);
+    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 || !task.attempts.length) {
+      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 (!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'))
+        : 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);
+      if (task.outcome === 'succeeded' && task.deliveryState === 'failed') {
+        const adapter = task.deliveryCache && !deliveryCacheNeedsProvider(root, task) ? undefined : await adapterFor(task, signal);
+        task = await runner.redeliver(task.id, adapter);
+      } else if (task.acceptance === 'accepted' && task.outcome === 'none' && task.remoteTaskId) {
+        task = await runner.observe(task.id, await adapterFor(task, signal), { resumeActive: true });
+      }
+    }
+    signal.throwIfAborted();
+    if (task.deliveryState !== 'ready') return facts(root, run);
+    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.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();
+      const artifact = createCoreArtifact(root, { artifactId: run.compare.artifactId, createdAt: run.createdAt,
+        bytes: diff.heatmap, expectedDigest: flowSha256(diff.heatmap), expectedSize: diff.heatmap.length,
+        kind: 'pixel-diff', mediaType: diff.mime,
+        metadata: { ratio: diff.ratio, diffPixels: diff.diffPixels, totalPixels: diff.totalPixels,
+          width: diff.width, height: diff.height, worstRegions: diff.worstRegions },
+        relations: [run.source.artifactId, run.output.artifactId].map(artifactId => ({ type: 'derived-from', artifactId })) });
+      run = updateFlowRun(root, run, { comparison: reference(artifact) });
+    }
+    return facts(root, run);
+  }
+
+  async function execute(name, input = {}) {
+    if (name === 'flow.init') {
+      exact(input, []);
+      return runtime.run('execute', ({ dataRoot }) => ({ contractVersion: 0, root: initializeFlowRoot(dataRoot) }));
+    }
+    if (name === 'flow.create') {
+      const owned = creationInput(input);
+      return runtime.run('execute', async ({ dataRoot, signal }) => {
+        const run = commitFlowCreation(dataRoot, await prepareCreation(dataRoot, signal, owned));
+        return facts(dataRoot, run);
+      });
+    }
+    if (name === 'flow.list') {
+      exact(input, []);
+      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, ...(run.source ? { source: run.source } : {}), modelRef: run.input.model_ref, taskId: flowStep(run).taskId })) };
+      });
+    }
+    if (name === 'flow.inspect') {
+      exact(input, ['run_id']);
+      return runtime.run('inspect', ({ dataRoot }) => facts(dataRoot, readFlowRun(dataRoot, input.run_id)));
+    }
+    if (name === 'flow.continue') {
+      exact(input, ['run_id']);
+      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', '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 (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].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);
+        }
+        if (!run.selection) flowFail('IRIS_FLOW_SELECTION_REQUIRED', '请先明确选择要导出的原图或新版');
+        return { ...facts(dataRoot, run), export: exportCoreArtifact(dataRoot, run.selection.artifactId, input.output_path) };
+      });
+    }
+    throw new TypeError('未知的内部 Flow 命令');
+  }
+  return Object.freeze({ execute, prepareCreation, inspectCreation: (root, intent, options) => {
+    if (intent.source) readReference(root, intent.source);
+    return facts(root, commitFlowCreation(root, intent, options));
+  } });
+}

package/lib/index.js

@@ -19,8 +19,8 @@ import { waitForModelWork } from './model-call-runtime.js';
 import { hasHostPort, requireHostPort } from './host-contract.js';
 import { createDshHostAdapter } from './dsh-host-adapter.js';
 import { withDshProviderConfig } from './dsh-provider-config.js';
-import { configureProviderHostForDsh } from './dsh-core-adapter.js';
-import { cropForDsh, diffForDsh, framesForDsh, summaryFramesForDsh, visionImageForDsh, htmlForDsh, inspectProviderTaskForDsh, projectCoreTaskForDsh, readCoreArtifactMediaForDsh, resumeProviderTaskWatchesForDsh, stopProviderTaskWatchesForDsh } from './dsh-core-adapter.js';
+import { createDshRuntime, dshCoreDataRoot } from './dsh-core-adapter.js';
+import { ModelPortError } from './model-port-contract.js';
 import { imageDimensions } from './pixels.js';
 import { runLocateRequest, runSummaryRequest, describeGeneratedImage } from './composite-vision-routing.js';
 import { normalizeSummarySource, summaryFrameRecords, summaryTimelineLabel } from './summary-input.js';
@@ -66,39 +66,47 @@ function outputDir() {
 
 /* ---------------- 媒体路由：/iris/media/:taskId/:token/:name ---------------- */
 
-let mediaRouteMounted = false;
-function mountIrisRoutes(routeCtx) {
+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' || mediaRouteMounted) return;
+  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)))
+      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)
     });
-    mediaRouteMounted = true;
+    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 长连接随插件停用一起关闭，不留悬挂连接
-      mediaRouteMounted = 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);
   }
 }
@@ -181,11 +189,11 @@ function coreTaskTerminalProblem(task, label = '任务') {
   return label + '需要人工处理';
 }
 
-async function awaitCoreTerminal(taskId, { timeoutMs, signal }) {
+async function awaitCoreTerminal(core, taskId, { timeoutMs, signal }) {
   const deadline = Date.now() + timeoutMs;
   for (;;) {
     if (signal?.aborted) throw new Error('已取消；Core 任务仍保留远端受理事实，可稍后查询');
-    const task = await inspectProviderTaskForDsh(taskId, { signal });
+    const task = await core.inspectProviderTaskForDsh(taskId, { signal });
     if (coreTaskWaitFinished(task)) return task;
     if (Date.now() > deadline) return null;
     await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -221,7 +229,25 @@ function safeRegister(host, definition) {
 
 export async function apply(ctx) {
   beginHostRuntime({ pluginId: IRIS_PLUGIN_ID, version: PACKAGE_VERSION });
-  const releaseProviderHost = configureProviderHostForDsh(() => dshHost(ctx));
+  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(() => () => {
+    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());
@@ -245,27 +271,18 @@ export async function apply(ctx) {
     if (resumed.length) console.log(`[iris] 已恢复接管 ${resumed.length} 个后台任务`);
   });
 
-  try {
-    const resumed = await resumeProviderTaskWatchesForDsh();
-    if (resumed.length) console.log(`[iris] 已恢复接管 ${resumed.length} 个 Core 图片任务`);
-  } catch (error) {
-    console.error('[iris] 恢复 Core 图片后台任务失败（已隔离，不影响宿主）:', error?.message || error);
-  }
-
-  // Fiber 清理：插件停用/更新时停掉 legacy 与 Core 的全部 Host 盯守句柄
-  guard('盯守句柄注册', () => {
-    ctx.effect(() => () => {
-      tasks.stopWatchAll();
-      stopProviderTaskWatchesForDsh();
-      releaseProviderHost();
-    });
+  // Owned background setup lets unload cancel a slow connection resolver during takeover.
+  void resumeProviderTaskWatchesForDsh().then(resumed => {
+    if (resumed.length) console.log('[iris] 已恢复接管 ' + resumed.length + ' 个 Core 媒体任务');
+  }, error => {
+    if (core.snapshot().state === 'open') console.error('[iris] 恢复 Core 后台任务失败:', error?.code || 'unknown');
   });
 
   // 媒体路由（视频/音频在对话流里的可播通路；图片仍走原生附件）
-  ctx.inject(['webServer'], mountIrisRoutes);
-  ctx.inject(['httpServer'], mountIrisRoutes);
+  ctx.inject(['webServer'], routeCtx => mountIrisRoutes(routeCtx, core, routes));
+  ctx.inject(['httpServer'], routeCtx => mountIrisRoutes(routeCtx, core, routes));
   // 若 webServer 已在运行，inject 回调也会触发；这里兜底立即挂载一次
-  guard('媒体路由兜底挂载', () => mountIrisRoutes(ctx));
+  guard('媒体路由兜底挂载', () => mountIrisRoutes(ctx, core, routes));
 
   // DSH 的 Skill registry 是可选宿主能力。存在时把 npm 包内三项 Skill 注册到
   // 全局层；项目目录中的同名 Skill 仍由 DSH 原生优先级覆盖。
@@ -283,13 +300,22 @@ export async function apply(ctx) {
     'iris_media_summarize', 'iris_locate', 'iris_long_ocr']);
   const visionTools = new Set(['iris_look_at_image', 'iris_relook_attachment', 'iris_media_summarize', 'iris_locate', 'iris_long_ocr']);
   function registerIrisTool(definition) {
-    safeRegister(host, { ...definition, execute(args, exec) {
-      const execute = async () => {
-        if (visionTools.has(definition.name) && !args?.model) await store.refreshAutomaticDirectories({ capability: 'vision', signal: exec.signal });
-        return definition.execute(args, exec);
-      };
-      return providerTools.has(definition.name)
-        ? withDshProviderConfig(dshHost(ctx), execute, { signal: exec.signal }) : execute();
+    safeRegister(host, { ...definition, execute(args, exec = {}) {
+      const owned = structuredClone(args || {});
+      return core.runHostOperation(signal => {
+        const execute = async () => {
+          if (visionTools.has(definition.name) && !owned.model) await store.refreshAutomaticDirectories({ capability: 'vision', signal });
+          signal.throwIfAborted();
+          return definition.execute(owned, { ...exec, signal });
+        };
+        return providerTools.has(definition.name)
+          ? withDshProviderConfig(dshHost(ctx), execute, { signal }) : execute();
+      }, { signal: exec.signal }).catch(error => {
+        if (visionTools.has(definition.name) && exec.signal?.aborted && error === exec.signal.reason) {
+          throw new ModelPortError('IRIS_MODEL_ABORTED');
+        }
+        throw error;
+      });
     } });
   }
   if (!hasHostPort(host, 'tools')) {
@@ -299,7 +325,7 @@ export async function apply(ctx) {
 
   async function coreImageToolResult(submitted, prompt, signal) {
     let final = await inspectProviderTaskForDsh(submitted.taskId, { signal });
-    if (!coreTaskWaitFinished(final)) final = await awaitCoreTerminal(submitted.taskId, { timeoutMs: AWAIT_MS.image, signal });
+    if (!coreTaskWaitFinished(final)) final = await awaitCoreTerminal(core, submitted.taskId, { timeoutMs: AWAIT_MS.image, signal });
     if (!final) return { blocks: [{ type: 'text', text: `[iris] Core 图片任务仍在后台观察（task: ${submitted.taskId}）。稍后可用 iris_task_status 查询进度与 Artifact。` }] };
     const terminalProblem = coreTaskTerminalProblem(final, '图像生成');
     if (terminalProblem) throw new Error(terminalProblem);
@@ -345,9 +371,9 @@ export async function apply(ctx) {
       const attachmentId = String(args.attachment_id || '').trim();
       if (Boolean(imagePath) === Boolean(attachmentId)) throw new Error('图片导入须选择image_path或attachment_id之一');
       const input = imagePath ? { image_path: imagePath } : {
-        image_bytes: (await resolveVisionImageInput(dshHost(ctx), exec, { attachment_id: attachmentId }, exec.signal)).bytes
+        image_bytes: (await resolveVisionImageInput(core, dshHost(ctx), exec, { attachment_id: attachmentId }, exec.signal)).bytes
       };
-      return runAction(dshHost(ctx), 'image_import', input, { signal: exec.signal });
+      return runAction(dshHost(ctx), 'image_import', input, { signal: exec.signal, core });
     }
   });
 
@@ -374,7 +400,7 @@ export async function apply(ctx) {
     isConcurrencySafe: () => false,
     async execute(args, exec) {
       const prompt = String(args.prompt || '').trim();
-      const submitted = await runAction(dshHost(ctx), 'image', args, { signal: exec.signal });
+      const submitted = await runAction(dshHost(ctx), 'image', args, { signal: exec.signal, core });
       if (submitted.storage === 'core') {
         return coreImageToolResult(submitted, prompt, exec.signal);
       }
@@ -393,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 });
       }
@@ -437,7 +463,7 @@ export async function apply(ctx) {
     output: { schema: { type: 'object' }, render: (_args, value) => value.blocks },
     isConcurrencySafe: () => false,
     async execute(args, exec) {
-      const submitted = await runAction(dshHost(ctx), 'image_edit', args, { signal: exec.signal });
+      const submitted = await runAction(dshHost(ctx), 'image_edit', args, { signal: exec.signal, core });
       return coreImageToolResult(submitted, String(args.prompt || '').trim(), exec.signal);
     }
   });
@@ -468,11 +494,11 @@ export async function apply(ctx) {
     output: { schema: { type: 'string' }, render: (_args, v) => [{ type: 'text', text: v }] },
     isConcurrencySafe: () => false,
     async execute(args, exec) {
-      const submitted = await runAction(dshHost(ctx), 'video', { ...args, session_id: exec.agent?.session?.id }, { signal: exec.signal });
+      const submitted = await runAction(dshHost(ctx), 'video', { ...args, session_id: exec.agent?.session?.id }, { signal: exec.signal, core });
       if (submitted.storage === 'core') {
         let final = await inspectProviderTaskForDsh(submitted.taskId, { signal: exec.signal });
         if (!coreTaskWaitFinished(final)) {
-          final = await awaitCoreTerminal(submitted.taskId, { timeoutMs: AWAIT_MS.video, signal: exec.signal });
+          final = await awaitCoreTerminal(core, submitted.taskId, { timeoutMs: AWAIT_MS.video, signal: exec.signal });
         }
         if (!final) {
           return `[iris] Core 视频任务已提交并转入后台观察（task: ${submitted.taskId}，remoteTask: ${submitted.remoteTaskId}）。\n` +
@@ -518,7 +544,7 @@ export async function apply(ctx) {
     output: { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: value }] },
     isConcurrencySafe: () => true,
     async execute(args, exec) {
-      const submitted = await runAction(dshHost(ctx), 'music', args, { signal: exec.signal });
+      const submitted = await runAction(dshHost(ctx), 'music', args, { signal: exec.signal, core });
       return submitted.text + '\nartifact: ' + submitted.artifactIds.join(', ') + '\n' +
         submitted.artifactIds.map(id => '[♪ 音乐播放](/iris/api/core/artifact/' + encodeURIComponent(id) + '/media)').join('\n');
     }
@@ -540,7 +566,7 @@ export async function apply(ctx) {
     output: { schema: { type: 'string' }, render: (_args, v) => [{ type: 'text', text: v }] },
     isConcurrencySafe: () => true,
     async execute(args, exec) {
-      const submitted = await runAction(dshHost(ctx), 'tts', args, { signal: exec.signal });
+      const submitted = await runAction(dshHost(ctx), 'tts', args, { signal: exec.signal, core });
       if (submitted.storage === 'core') {
         const final = await inspectProviderTaskForDsh(submitted.taskId, { signal: exec.signal });
         const terminalProblem = coreTaskTerminalProblem(final, '语音合成');
@@ -577,11 +603,11 @@ export async function apply(ctx) {
     output: { schema: { type: 'string' }, render: (_args, v) => [{ type: 'text', text: v }] },
     isConcurrencySafe: () => false,
     async execute(args, exec) {
-      const submitted = await runAction(dshHost(ctx), 'transcribe', args, { signal: exec.signal });
+      const submitted = await runAction(dshHost(ctx), 'transcribe', args, { signal: exec.signal, core });
       if (submitted.storage === 'core') {
         let final = await inspectProviderTaskForDsh(submitted.taskId, { signal: exec.signal });
         if (!coreTaskWaitFinished(final)) {
-          final = await awaitCoreTerminal(submitted.taskId, { timeoutMs: AWAIT_MS.transcribe, signal: exec.signal });
+          final = await awaitCoreTerminal(core, submitted.taskId, { timeoutMs: AWAIT_MS.transcribe, signal: exec.signal });
         }
         if (!final) {
           return `[iris] Core 转写任务已提交并转入后台观察（task: ${submitted.taskId}）。完成后用 iris_task_status 查询进度与 Artifact。`;
@@ -641,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}`
@@ -714,8 +740,8 @@ export async function apply(ctx) {
               try {
                 const audio = await extractAudioTrack({ inputPath: p, signal });
                 try {
-                  const submitted = await runAction(dshHost(ctx), 'transcribe', { audio_path: audio.filePath }, { signal });
-                  const final = await awaitCoreTerminal(submitted.taskId, { timeoutMs: 120000, signal });
+                  const submitted = await runAction(dshHost(ctx), 'transcribe', { audio_path: audio.filePath }, { signal, core });
+                  const final = await awaitCoreTerminal(core, submitted.taskId, { timeoutMs: 120000, signal });
                   if (final?.outcome === 'succeeded' && final.deliveryState === 'ready') {
                     const texts = [];
                     for (const artifactId of final.artifactIds) {
@@ -738,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`
@@ -795,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;
         }
       });
@@ -827,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 };
         }
       });
@@ -852,7 +878,7 @@ export async function apply(ctx) {
     output: { schema: { type: 'string' }, render: (_args, v) => [{ type: 'text', text: v }] },
     isConcurrencySafe: () => true,
     async execute(args) {
-      const result = await runAction(dshHost(ctx), 'status', args || {});
+      const result = await runAction(dshHost(ctx), 'status', args || {}, { core });
       return result.text;
     }
   });
@@ -894,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`
@@ -940,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`
@@ -985,7 +1011,7 @@ export async function apply(ctx) {
     async execute(args, exec) {
       const r = await runLocateRequest(dshHost(ctx), {
         providers: store.pickAllFor(cap.CAPABILITIES.VISION), onRateLimit: store.recordRateLimit, onModelAvailability: store.recordAvailability, model: args.model, target: args.target,
-        prepareImage: signal => resolveVisionImageInput(dshHost(ctx), exec, args, signal), signal: exec.signal
+        prepareImage: signal => resolveVisionImageInput(core, dshHost(ctx), exec, args, signal), signal: exec.signal
       });
       const { width, height } = r;
       const sourceNote = args.artifact_id ? `\nCore Artifact: ${args.artifact_id}` : '';
@@ -1031,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`
@@ -1074,7 +1100,7 @@ export async function apply(ctx) {
       const host = dshHost(ctx);
       const result = await runOcrRequest(host, {
         providers: store.pickAllFor(cap.CAPABILITIES.VISION), onRateLimit: store.recordRateLimit, onModelAvailability: store.recordAvailability,
-        prepareImage: operationSignal => resolveVisionImageInput(host, exec, args, operationSignal),
+        prepareImage: operationSignal => resolveVisionImageInput(core, host, exec, args, operationSignal),
         chunkHeight: args.chunk_height,
         overlap: args.overlap,
         signal: exec.signal
@@ -1133,10 +1159,10 @@ async function resolveImageInput(host, exec, { image_path, attachment_id }) {
 }
 
 /** 视觉解引用在整体预算内；路径限额读，Host 会话/附件等待可取消。 */
-async function resolveVisionImageInput(host, exec, input, signal) {
+async function resolveVisionImageInput(core, host, exec, input, signal) {
   const source = normalizeVisionImageSource(input, { allowAttachment: true });
   const { image_path, artifact_id, attachment_id } = input;
-  if (source === 'artifact_id') return visionImageForDsh({ artifactId: artifact_id, signal });
+  if (source === 'artifact_id') return core.visionImageForDsh({ artifactId: artifact_id, signal });
   if (image_path) {
     const file = String(image_path).trim();
     const mediaType = MEDIA_TYPES[path.extname(file).toLowerCase()];

package/lib/local-api-projection.js

@@ -0,0 +1,32 @@
+// HTTP DTOs whitelist existing Core facts; never expose records or configuration wholesale.
+import { isAudioRecipe } from './audio-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)) {
+    throw new TypeError('不支持的流程契约或状态');
+  }
+  const { run, task } = facts;
+  const ref = value => value ? { artifactId: value.artifactId } : null;
+  return {
+    contractVersion: 0, id: run.id, recipe: run.recipe, revision: run.revision,
+    createdAt: run.createdAt, updatedAt: run.updatedAt, status: facts.status,
+    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.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,
+    metrics: facts.metrics ? Object.fromEntries(['ratio', 'diffPixels', 'totalPixels', 'width', 'height']
+      .map(key => [key, facts.metrics[key]])) : null
+  };
+}
+
+export function projectLocalApiRunSummary(run) {
+  return { id: run.id, recipe: run.recipe, createdAt: run.createdAt,
+    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 };
+}