@mokuyoaxis/dsh-iris 0.2.5 → 0.2.7

package/lib/composite-vision-routing.js

@@ -8,10 +8,10 @@ import { VISION_BUDGET } from './vision-core.js';
 import { normalizeModelCall } from './model-port-contract.js';
 import { waitForModelWork } from './model-call-runtime.js';
 
-export async function runLocateRequest(host, { providers = [], model, target, image, prepareImage, signal, budget = VISION_BUDGET, onRateLimit }) {
+export async function runLocateRequest(host, { providers = [], model, target, image, prepareImage, signal, budget = VISION_BUDGET, onRateLimit, onModelAvailability }) {
   target = normalizeLocateTarget(target);
   const inputs = new Map();
-  const result = await runVisionOperation(host, { providers, model, signal, budget, onRateLimit, prepareImages: true,
+  const result = await runVisionOperation(host, { providers, model, signal, budget, onRateLimit, onModelAvailability, prepareImages: true,
     orientImages: true, prepareImageRequest: createLocateImageRequest(target, inputs) }, async (ports, operation) => {
     const resolved = await waitForModelWork(() => prepareImage ? prepareImage(operation.signal) : image, operation.signal);
     const source = normalizeModelCall(ports[0].describe(), { prompt: target, image: resolved }, { budget }).request.image;
@@ -23,8 +23,8 @@ export async function runLocateRequest(host, { providers = [], model, target, im
   return location;
 }
 
-export async function runSummaryRequest(host, { providers = [], model, prepareMedia, frames, question, transcript, signal, budget = VISION_BUDGET, onRateLimit }) {
-  return runVisionOperation(host, { providers, model, signal, budget, onRateLimit }, async (ports, operation) => {
+export async function runSummaryRequest(host, { providers = [], model, prepareMedia, frames, question, transcript, signal, budget = VISION_BUDGET, onRateLimit, onModelAvailability }) {
+  return runVisionOperation(host, { providers, model, signal, budget, onRateLimit, onModelAvailability }, async (ports, operation) => {
     const media = await waitForModelWork(() => prepareMedia ? prepareMedia(operation.signal) : { frames, transcript }, operation.signal);
     const completion = await summarizeMedia({ ports, frames: media.frames, question, transcript: media.transcript,
       operation, budget });
@@ -33,9 +33,9 @@ export async function runSummaryRequest(host, { providers = [], model, prepareMe
 }
 
 /** 增强描述沿用共享调用；失败不改变已经完成的媒体交付。 */
-export async function describeGeneratedImage(host, { providers = [], originalPrompt, image, prepareImage, signal, onRateLimit }) {
+export async function describeGeneratedImage(host, { providers = [], originalPrompt, image, prepareImage, signal, onRateLimit, onModelAvailability }) {
   try {
-    const result = await runVisionRequest(host, { providers, image, prepareImage, signal, onRateLimit,
+    const result = await runVisionRequest(host, { providers, image, prepareImage, signal, onRateLimit, onModelAvailability,
       question: `用不超过两句话描述这张图片的主题与构图。生成该图的提示词是：「${String(originalPrompt).slice(0, 200)}」` });
     return result.answer.slice(0, 300);
   } catch (_) { return ''; }

package/lib/config.js

@@ -1,5 +1,8 @@
 'use strict';
 import { normalizeVisionInputLimits } from './vision-image-input.js';
+import { scopedProvider } from './provider-config-scope.js';
+import { currentModelDirectory, modelDirectoryBinding, modelAvailabilityBinding, modelUnavailable, modelUnavailableReason, validateModelDirectory } from './model-directory.js';
+import { refreshModelDirectory } from './model-directory-service.js';
 /**
  * Iris 配置存储：$DSH_HOME/iris/v1/providers.json
  * Iris 独立持有配置；旧工作台仅作为用户显式指定的一次性导入来源。
@@ -19,7 +22,7 @@ import {
   healthObservationState,
   isDefinitiveHealthFailure,
   newestHealthEvidence,
-  modelRateLimit, recordModelRateLimit, clearModelRateLimit, clearModelCapabilityHealth
+  modelRateLimit, recordModelRateLimit, clearModelRateLimit, clearModelCapabilityHealth, recordModelAvailability, resetHealthOnCriticalChange
 } from './provider-health.js';
 
 function isPlainObject(value) {
@@ -30,12 +33,21 @@ function validateStoredConfig(value) {
   if (!isPlainObject(value)) throw new Error('配置根节点必须是对象');
   if (!Array.isArray(value.providers)) throw new Error('providers 必须是数组');
   if (!isPlainObject(value.assignments)) throw new Error('assignments 必须是对象');
+  for (const [capability, assignment] of Object.entries(value.assignments)) models.functionPolicy(assignment, capability);
   for (const provider of value.providers) {
     if (!isPlainObject(provider)) throw new Error('provider 条目必须是对象');
+    validateModelDirectory(provider.modelDirectory);
     if (provider.id !== undefined && typeof provider.id !== 'string') throw new Error('provider.id 必须是字符串');
     if (provider.baseUrl !== undefined && typeof provider.baseUrl !== 'string') throw new Error('provider.baseUrl 必须是字符串');
     if (provider.mediaBaseUrl !== undefined && typeof provider.mediaBaseUrl !== 'string') throw new Error('provider.mediaBaseUrl 必须是字符串');
     if (provider.apiKey !== undefined && typeof provider.apiKey !== 'string') throw new Error('provider.apiKey 必须是字符串');
+    if (provider.dshProvider !== undefined) {
+      const ref = provider.dshProvider;
+      if (!isPlainObject(ref) || typeof ref.provider !== 'string' || !ref.provider.trim()
+          || typeof ref.settingsNs !== 'string' || !ref.settingsNs.trim()
+          || Object.keys(ref).some(key => !['provider', 'settingsNs'].includes(key))) throw new Error('DSH 连接引用无效');
+      if (provider.apiKey !== undefined || provider.baseUrl !== undefined) throw new Error('DSH 引用不能同时保存密钥或普通 Base URL');
+    }
     if (provider.models !== undefined && !Array.isArray(provider.models)) throw new Error('provider.models 必须是数组');
     for (const model of provider.models || []) {
       if (typeof model === 'string') continue;
@@ -58,6 +70,7 @@ function authModeOf(provider) {
 /** 该供应商是否缺少必需凭据（'none' 认证永不缺）。 */
 function missingCredentials(provider) {
   if (!provider || authModeOf(provider) === 'none') return false;
+  if (provider.dshProvider) return false;
   return typeof provider.apiKey !== 'string' || !provider.apiKey.trim();
 }
 
@@ -172,7 +185,37 @@ export function importFromWorkbench(workbenchConfigPath) {
 }
 
 export function providers() {
-  return load().providers.filter(isConfiguredProvider);
+  return runtimeProviders().filter(isConfiguredProvider);
+}
+
+/** Runtime copies may contain Host-resolved credentials; never persist these copies. */
+export function runtimeProviders() {
+  return load().providers.map(scopedProvider);
+}
+
+/** 目录更新只保存可选元数据，不保存宿主解析出的连接副本。 */
+export function saveModelDirectory(providerId, directory) {
+  const provider = load().providers.find(item => item.id === providerId);
+  const current = runtimeProviders().find(item => item.id === providerId);
+  if (!provider || !current || modelDirectoryBinding(current) !== directory.binding) return false;
+  provider.modelDirectory = directory;
+  // 同一次操作的已解析副本也使用最新快照。
+  if (current !== provider) current.modelDirectory = directory;
+  persist();
+  return true;
+}
+
+export async function refreshProviderDirectories({ providerId, force = false, signal } = {}) {
+  const selected = providers().filter(provider => !providerId || provider.id === providerId);
+  return Promise.all(selected.map(provider => refreshModelDirectory(provider, { force, signal,
+    save: directory => saveModelDirectory(provider.id, directory) })));
+}
+
+export async function refreshAutomaticDirectories({ capability, signal } = {}) {
+  const capabilities = (capability ? [capability] : Object.values(cap.CAPABILITIES)).filter(c => models.functionPolicy(assignments()[c], c).mode === 'auto');
+  const selected = providers().filter(provider => models.providerModels(provider).some(model => model.capabilities.some(c => capabilities.includes(c))));
+  return Promise.all(selected.map(provider => refreshModelDirectory(provider, { signal,
+    save: directory => saveModelDirectory(provider.id, directory) })));
 }
 
 export function providerById(id) {
@@ -183,7 +226,7 @@ export function providerById(id) {
 const FIELD_OF = models.CAP_FIELD;
 
 /**
- * 严格选择：仅从功能分配名单取第一个可用模型。
+ * 按当前功能策略取第一个可用模型。
  * 返回该模型所属 provider 的副本，并把该能力的模型字段设为选中模型。
  * 向后兼容：调用方继续读 provider.apiKey / provider.imageModel 等。
  * 无可用模型 → null（不再兜底到任意 provider）。
@@ -194,12 +237,12 @@ export function pickFor(capability) {
 
 /**
  * 同一能力的有序 provider 列表（供 failover 依次尝试）：
- * 只使用已分配顺序，不补入全局池。
+ * 自动池按登记顺序选择；手选名单不补池，停用没有候选。
  * 一个 provider 若池里有多个该能力模型，会返回多条（各自带不同模型）。
  */
-export function pickAllFor(capability, { includeRateLimited = false } = {}) {
-  const pool = models.modelPool(providers(), { includeHostVision: true });
-  const chosen = models.orderedModels(pool, capability, assignments()[capability], { includeRateLimited });
+export function pickAllFor(capability, { includeRateLimited = false, includeUnavailable = false } = {}) {
+  const pool = models.functionModelPool(providers(), capability, assignments()[capability], { includeHostVision: true });
+  const chosen = models.orderedModels(pool, capability, assignments()[capability], { includeRateLimited, includeUnavailable });
   const out = [];
   for (const m of chosen) {
     if (m.ref === models.HOST_VISION_REF) {
@@ -226,8 +269,11 @@ export function assignmentOrder(capability) {
   const a = assignments()[capability];
   if (!a) return [];
   const pool = models.modelPool(allProviders(), { includeHostVision: true });
+  const policy = models.functionPolicy(a, capability);
+  if (policy.mode === 'auto') return models.orderedModels(pool, capability, a, { includeRateLimited: true, includeUnavailable: true }).map(model => model.ref);
+  if (policy.mode === 'disabled') return [];
   const refs = [];
-  for (const raw of (Array.isArray(a) ? a : [a])) {
+  for (const raw of policy.models) {
     const m = resolveAssignment(pool, raw, capability);
     if (m && !refs.includes(m.ref)) refs.push(m.ref);
     else if (!m && typeof raw === 'string' && models.parseModelRef(raw) && !refs.includes(raw)) refs.push(raw);
@@ -284,6 +330,47 @@ export function clearAssignment(capability) {
   return true;
 }
 
+/** Explicit policy changes preserve the previous manual list for a later switch. */
+export function setFunctionPolicy(capability, mode, { hostVision } = {}) {
+  if (!cap.isKnownCapability(capability)) throw new TypeError('未知功能');
+  const c = load();
+  const previous = models.functionPolicy(c.assignments[capability], capability);
+  const next = { mode, models: models.savedAssignmentRefs(models.modelPool(c.providers, { includeHostVision: true }), capability, previous.models) };
+  if (capability === cap.CAPABILITIES.VISION) next.hostVision = hostVision === undefined ? previous.hostVision : hostVision;
+  models.functionPolicy(next, capability);
+  c.assignments[capability] = next;
+  persist();
+  return next;
+}
+
+/** One user confirmation updates capabilities and optional automatic use atomically. */
+export function confirmModelUsage(id, modelId, capabilities, { enableAutomatic = false, musicProtocol } = {}) {
+  const c = load();
+  const provider = c.providers.find(item => item.id === id);
+  if (!provider) throw new TypeError('供应商不存在');
+  if (typeof modelId !== 'string' || !modelId.trim() || !Array.isArray(capabilities)
+      || !capabilities.every(cap.isKnownCapability) || typeof enableAutomatic !== 'boolean') throw new TypeError('请填写模型名称并确认已知功能');
+  if (musicProtocol !== undefined) normalizeMusicProtocol(musicProtocol);
+  const entries = (Array.isArray(provider.models) ? provider.models : models.providerModels(provider)).map(model => typeof model === 'string' ? { id: model } : { ...model });
+  let entry = entries.find(model => model.id === modelId.trim());
+  if (!entry) { entry = { id: modelId.trim() }; entries.push(entry); }
+  entry.capabilities = [...new Set(capabilities)];
+  entry.source = 'manual';
+  provider.models = entries;
+  if (musicProtocol !== undefined) {
+    if (entry.musicProtocol !== musicProtocol) clearModelCapabilityHealth(provider, entry.id, cap.CAPABILITIES.MUSIC);
+    entry.musicProtocol = musicProtocol;
+  }
+  if (enableAutomatic) for (const capability of entry.capabilities) {
+    const previous = models.functionPolicy(c.assignments[capability], capability);
+    c.assignments[capability] = { mode: 'auto', models: models.savedAssignmentRefs(models.modelPool(c.providers, { includeHostVision: true }), capability, previous.models),
+      ...(capability === cap.CAPABILITIES.VISION ? { hostVision: previous.hostVision } : {}) };
+  }
+  pruneHealthToEffectiveModels(provider);
+  persist();
+  return entry;
+}
+
 /** 某 provider 的模型池覆盖的能力集合（合并各模型的能力标签） */
 export function capabilitiesOf(p) {
   const caps = new Set();
@@ -293,11 +380,6 @@ export function capabilitiesOf(p) {
   return [...caps];
 }
 
-const HEALTH_SENSITIVE_FIELDS = new Set([
-  'auth', 'type', 'baseUrl', 'mediaBaseUrl', 'apiKey', 'mediaProtocol',
-  'imageModel', 'videoModel', 'ttsModel', 'transcribeModel', 'visionModel'
-]);
-
 function healthContainer(provider) {
   const current = provider.health;
   if (current && current.version === 1 && Number.isSafeInteger(current.revision)
@@ -318,7 +400,7 @@ function safeHealthNote(provider, value) {
   const raw = String(value ?? '').trim();
   if (!raw) return '';
   let note = redactProviderMessage(raw, 200);
-  const key = String(provider && provider.apiKey || '');
+  const key = String(provider && scopedProvider(provider).apiKey || '');
   if (key) note = note.split(key).join('[REDACTED]');
   return note;
 }
@@ -330,7 +412,9 @@ function observationEvidence(provider, result, fallbackSource) {
   return {
     at: new Date(Number.isFinite(atMs) ? atMs : Date.now()).toISOString(),
     source: ['probe', 'task'].includes(result && result.source) ? result.source : fallbackSource,
+    ...(result?.stage === 'poll' ? { stage: 'poll' } : {}),
     category: String(result && result.category || (result && result.ok ? 'success' : 'unknown')).slice(0, 40),
+    ...(typeof result?.providerCode === 'string' ? { providerCode: safeHealthNote(provider, result.providerCode) } : {}),
     ...(Number.isInteger(status) && status >= 100 && status <= 599 ? { httpStatus: status } : {}),
     ...(note ? { note } : {})
   };
@@ -340,6 +424,8 @@ function applyProviderHealth(provider, modelId, capability, result, fallbackSour
   const model = String(modelId || '').trim();
   if (!provider || !model || !cap.isKnownCapability(capability)) return false;
   const health = healthContainer(provider);
+  const scoped = scopedProvider(provider);
+  if (scoped !== provider) scoped.health = health;
   let observation = health.observations.find((item) => item && item.modelId === model
     && item.capability === capability);
   if (!observation) {
@@ -347,6 +433,12 @@ function applyProviderHealth(provider, modelId, capability, result, fallbackSour
     health.observations.push(observation);
   }
   const evidence = observationEvidence(provider, result || {}, fallbackSource);
+  const effective = { ...scopedProvider(provider), health };
+  if (recordModelAvailability(effective, model, capability, { ...result, ...evidence,
+    binding: result?.binding || modelAvailabilityBinding(effective, model, capability) }) && observation.availability?.state === 'blocked') {
+    const directory = currentModelDirectory(effective);
+    if (directory) directory.invalidatedAt = evidence.at;
+  }
   recordModelRateLimit(provider, model, { ...evidence, retryAfterMs: result?.retryAfterMs, until: result?.until, reason: result?.reason });
   if (result && result.ok === true) {
     observation.lastSuccess = evidence;
@@ -382,16 +474,6 @@ function pruneModelHealth(provider, modelId) {
   provider.health.observations = provider.health.observations.filter((item) => item.modelId !== modelId);
 }
 
-function resetHealthOnCriticalChange(previous, next, patch) {
-  const changed = [...HEALTH_SENSITIVE_FIELDS].some((key) =>
-    Object.prototype.hasOwnProperty.call(patch, key) && previous[key] !== next[key]);
-  if (!changed) return;
-  const current = previous.health;
-  const revision = Number.isSafeInteger(current && current.revision) ? current.revision + 1 : 1;
-  next.health = { version: 1, revision, observations: [],
-    ...(current?.rateLimits?.length ? { rateLimits: current.rateLimits } : {}) };
-}
-
 /** 记录显式实测或真实任务观察；限流资格另存，保留原成功事实。 */
 export function recordProviderHealth(id, modelId, capability, result) {
   const c = load();
@@ -403,6 +485,14 @@ export function recordProviderHealth(id, modelId, capability, result) {
   return true;
 }
 
+/** Adapter提交边界的可用性事件；poll不会调用这一入口。 */
+export function recordAvailability({ providerId, modelId, capability, ...result }) {
+  const known = { image: cap.CAPABILITIES.IMAGE, video: cap.CAPABILITIES.VIDEO, music: cap.CAPABILITIES.MUSIC }[capability] || capability;
+  const current = runtimeProviders().find(provider => provider.id === providerId);
+  if (!current || result.binding && modelAvailabilityBinding(current, modelId, known) !== result.binding) return false;
+  return recordProviderHealth(providerId, modelId, known, result);
+}
+
 /** DSH 调用边界记录冷却或明确耗尽；覆盖同账号该模型的所有能力。 */
 export function recordRateLimit({ providerId, modelId, capability, httpStatus = 429, category = 'rate_limit', at, until, retryAfterMs, reason }) {
   const known = { image: 'image-gen', video: 'video-gen' }[capability] || capability;
@@ -421,6 +511,10 @@ export function modelHealth(id, modelId, capability, { now = Date.now() } = {})
     source: blocked.source, category: blocked.category, httpStatus: blocked.httpStatus,
     ...(blocked.until ? { retryAt: blocked.until } : { reason: blocked.reason }),
     note: blocked.until ? '429 限流冷却，暂时跳过' : '额度或预算耗尽后已停用，手动实测成功后恢复' };
+  const unavailable = modelUnavailable(scopedProvider(provider), modelId, capability, { allowUnresolvedConnections: true });
+  if (unavailable) return { status: 'failed', modelUnavailable: true, reason: 'model_not_found',
+    observedAt: unavailable.at, source: unavailable.source, httpStatus: 404, category: 'invalid_request',
+    note: modelUnavailableReason() };
   const observation = healthObservation(provider, modelId, capability);
   const status = healthObservationState(observation, { now });
   const evidence = status === 'verified'
@@ -441,12 +535,18 @@ export function modelHealth(id, modelId, capability, { now = Date.now() } = {})
 /** 当前有序 failover 路径的健康快照；只含脱敏标量，不触发网络。 */
 export function providerHealthSnapshot({ now = Date.now() } = {}) {
   const capabilities = {};
+  // A stored Host reference is configured without local endpoint/key fields.
+  // This snapshot reports configuration and past evidence, not live readiness.
+  const healthProviders = runtimeProviders().filter(provider => provider.enabled !== false
+    && (provider.dshProvider || isConfiguredProvider(provider)));
   for (const capability of Object.values(cap.CAPABILITIES)) {
-    const candidates = pickAllFor(capability, { includeRateLimited: true }).map((provider) => {
-      const modelId = String(provider[FIELD_OF[capability]] || '');
-      const health = provider.id === models.HOST_VISION_REF ? { status: 'configured', source: 'configuration' }
-        : modelHealth(provider.id, modelId, capability, { now });
-      return { providerId: provider.id, modelId, ...health };
+    const pool = models.functionModelPool(healthProviders, capability, assignments()[capability], {
+      includeHostVision: true, allowUnresolvedConnections: true
+    });
+    const candidates = models.orderedModels(pool, capability, assignments()[capability], { includeRateLimited: true, includeUnavailable: true }).map((model) => {
+      const health = model.ref === models.HOST_VISION_REF ? { status: 'configured', source: 'configuration' }
+        : modelHealth(model.providerId, model.id, capability, { now });
+      return { providerId: model.providerId, modelId: model.id, ...health };
     });
     const status = aggregateHealthStates(candidates.map((item) => item.status));
     const newest = [...candidates]
@@ -480,6 +580,17 @@ export function upsert(provider) {
   const { id, ...input } = provider;
   // PATCH 语义：缺失字段和 undefined 都不覆盖旧值；null/空串仍是显式更新。
   const rest = Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+  const existing = id && c.providers.find(item => item.id === id);
+  const reference = rest.dshProvider || existing?.dshProvider;
+  if (reference) {
+    if (!isPlainObject(reference) || typeof reference.provider !== 'string' || !reference.provider.trim()
+        || typeof reference.settingsNs !== 'string' || !reference.settingsNs.trim()
+        || Object.keys(reference).some(key => !['provider', 'settingsNs'].includes(key))) throw new Error('DSH 连接引用无效');
+    if (['apiKey', 'baseUrl'].some(key => rest[key] !== undefined || existing?.[key] !== undefined)) {
+      throw new Error('DSH 引用不保存密钥或普通 Base URL；请新建引用供应商');
+    }
+    rest.dshProvider = { provider: reference.provider.trim(), settingsNs: reference.settingsNs.trim() };
+  }
   if (rest.visionInput !== undefined) rest.visionInput = normalizeVisionInputLimits(rest.visionInput) || null;
   if (Array.isArray(rest.models)) rest.models = rest.models.map(model => typeof model === 'string' ? model : ({ ...model,
     ...(model?.imageProtocol !== undefined ? { imageProtocol: normalizeImageProtocol(model.imageProtocol) } : {}),

package/lib/core-artifact-store.js

@@ -422,6 +422,11 @@ export function inspectCoreArtifact(dataRoot, id) {
   return publicArtifact(readArtifact(dataRoot, id).manifest);
 }
 
+/** 先检查清单/普通文件大小，用于媒体边界限额；读取或提供字节时仍必须校验内容哈希。 */
+export function inspectCoreArtifactMetadata(dataRoot, id) {
+  return publicArtifact(readArtifact(dataRoot, id, { verifyContent: false }).manifest);
+}
+
 /** 供宿主投影层读取已经校验过内容哈希的字节；不暴露 Core 内部路径。 */
 export function readCoreArtifactBytes(dataRoot, id) {
   const hit = readArtifact(dataRoot, id);

package/lib/core-maintenance.js

@@ -2,9 +2,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { inspectCoreArtifact, refreshCoreArtifactInventory } from './core-artifacts.js';
-import { inspectCoreTask, listCoreTasks } from './core-tasks.js';
+import { assertFlowTaskMatches, inspectCoreTask, listCoreTasks } from './core-tasks.js';
 import { atomicWritePrivate } from './private-storage.js';
 import { readDeliveryCache } from './core-delivery-cache.js';
+import { flowReferences } from './flow-store.js';
+import { creationReferences } from './creation-request-store.js';
 
 const TASK = /^task_[a-f0-9]{24}$/;
 const ARTIFACT = /^artifact_[a-f0-9]{24}$/;
@@ -51,7 +53,18 @@ function inventory(root) {
   }
   const artifacts = names(root, 'artifact-store/v0/records').filter(name => ARTIFACT.test(name.slice(0, -5)) && name.endsWith('.json'))
     .map(name => inspectCoreArtifact(root, name.slice(0, -5)));
-  return { tasks, artifacts };
+  const flows = flowReferences(root);
+  for (const reference of flows) {
+    if (reference.run.edit.claimed && !tasks.some(task => task.id === reference.run.edit.taskId)) {
+      fail('IRIS_FLOW_TASK_CONFLICT', '流程已建立的 Task 丢失，停止管理');
+    }
+  }
+  for (const task of tasks.filter(task => task.flowBinding)) {
+    const reference = flows.find(item => item.run.id === task.flowBinding.runId);
+    if (!reference) fail('IRIS_FLOW_TASK_CONFLICT', '流程 Task 的 Run 记录丢失，停止管理');
+    assertFlowTaskMatches(task, reference.run);
+  }
+  return { tasks, artifacts, flows, creations: creationReferences(root) };
 }
 
 function ids(value, pattern, label) {
@@ -65,6 +78,14 @@ export function planCoreDeletion(root, input) {
   if (!taskIds.length && !artifactIds.length) fail('IRIS_COMMAND_INPUT_INVALID', '请明确指定 Task 或 Artifact ID');
   const existing = inventory(root), selectedTasks = new Set(taskIds), selectedArtifacts = new Set(artifactIds);
   const blockers = [], files = [];
+  for (const reference of existing.creations) {
+    for (const id of reference.taskIds) if (selectedTasks.has(id)) blockers.push({ id, referencedBy: reference.requestId, reason: 'creation_task_reference' });
+    for (const id of reference.artifactIds) if (selectedArtifacts.has(id)) blockers.push({ id, referencedBy: reference.requestId, reason: 'creation_artifact_reference' });
+  }
+  for (const reference of existing.flows) {
+    for (const id of reference.taskIds) if (selectedTasks.has(id)) blockers.push({ id, referencedBy: reference.run.id, reason: 'flow_task_reference' });
+    for (const id of reference.artifactIds) if (selectedArtifacts.has(id)) blockers.push({ id, referencedBy: reference.run.id, reason: 'flow_artifact_reference' });
+  }
   for (const id of taskIds) {
     const task = inspectCoreTask(root, id);
     if (task.phase !== 'terminal' || task.acceptance === 'unknown' || task.outcome === 'unknown') blockers.push({ id, reason: 'task_not_settled' });
@@ -115,6 +136,8 @@ export function planCoreCleanup(root, { older_than_ms = 3600000 } = {}) {
   if (!Number.isSafeInteger(older_than_ms) || older_than_ms < 60000) fail('IRIS_COMMAND_INPUT_INVALID', 'older_than_ms 至少为 60000');
   const existing = inventory(root);
   const referenced = new Set(existing.artifacts.map(artifact => artifact.id));
+  for (const reference of existing.creations) for (const id of reference.artifactIds) referenced.add(id);
+  for (const reference of existing.flows) for (const id of reference.artifactIds) referenced.add(id);
   for (const artifact of existing.artifacts) for (const edge of artifact.relations) referenced.add(edge.artifactId);
   for (const task of existing.tasks) for (const id of task.artifactIds) referenced.add(id);
   for (const task of existing.tasks) if (task.deliveryCache && task.deliveryState !== 'ready') {

package/lib/core-runtime.js

@@ -13,6 +13,7 @@ import {
   transitionCoreLifecycle
 } from './core-contract.js';
 import { ensurePrivateDir } from './private-storage.js';
+import { listCreationRequests } from './creation-request-store.js';
 import { WRITER_LEASE_DIR, WRITER_INTENT_FILE, publishLeaseRecord, readWriterLease,
   removeWriterIntent, retireLeaseDirectory, writerOwnerStatus } from './core-writer-lease.js';
 
@@ -162,6 +163,24 @@ export function createCoreRuntime(input) {
     }
     const candidateRoot = physicalDataRoot(options);
     const candidateLease = options.mode === 'writer' ? acquireWriterLease(candidateRoot, instanceId) : null;
+    if (candidateLease) {
+      try { listCreationRequests(candidateRoot); }
+      catch (error) {
+        try { releaseWriterLease(candidateLease); }
+        catch (cleanupError) {
+          // Retained ownership must also make dispose fail, so the application stops its writer queue.
+          root = candidateRoot; lease = candidateLease;
+          lifecycle = transitionCoreLifecycle(lifecycle, 'dispose');
+          abortController.abort();
+          const failure = Object.assign(new AggregateError([error, cleanupError], '请求区检查失败且租约未能安全释放'),
+            { code: 'IRIS_CORE_LEASE_INVALID' });
+          disposePromise = Promise.reject(failure);
+          void disposePromise.catch(() => {});
+          throw failure;
+        }
+        throw error;
+      }
+    }
     root = candidateRoot;
     lease = candidateLease;
     lifecycle = transitionCoreLifecycle(lifecycle, 'start');

package/lib/core-tasks.js

@@ -3,11 +3,12 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { atomicWritePrivate, ensurePrivateDir } from './private-storage.js';
+import { atomicCreatePrivate, atomicWritePrivate, ensurePrivateDir } from './private-storage.js';
 import { parseModelRef } from './models.js';
 import { providerErrorRecord } from './provider-contract.js';
 import { deriveLegacyStatus, semanticViolations } from './task-semantics.js';
 import { readDeliveryCache } from './core-delivery-cache.js';
+import { flowTaskBinding, readFlowRun, validFlowBinding } from './flow-store.js';
 
 const STORE_DIR = 'task-store';
 const STORE_VERSION = 'v0';
@@ -110,6 +111,7 @@ function validateRecord(record, expectedId) {
       || (record.deliveryCache !== undefined && record.deliveryCache !== true)
       || (record.providerBinding !== undefined && !PROVIDER_BINDING.test(record.providerBinding))
       || (record.retriedFrom !== undefined && !TASK_ID.test(record.retriedFrom))
+      || (record.flowBinding !== undefined && (record.capability !== 'image' || !validFlowBinding(record.flowBinding)))
       || (record.sourceArtifactId !== undefined && (record.capability !== 'image' || !ARTIFACT_ID.test(record.sourceArtifactId)))) {
     fail('IRIS_TASK_INVALID', 'Task 记录结构无效');
   }
@@ -143,11 +145,12 @@ function readRecord(dataRoot, id) {
   return validateRecord(record, id);
 }
 
-function writeRecord(dataRoot, record) {
+function writeRecord(dataRoot, record, exclusive = false) {
   validateRecord(record, record.id);
   try {
     ensurePrivateDir(taskDirectory(dataRoot));
-    atomicWritePrivate(taskFile(dataRoot, record.id), JSON.stringify(record, null, 2) + '\n');
+    const publish = exclusive ? atomicCreatePrivate : atomicWritePrivate;
+    publish(taskFile(dataRoot, record.id), JSON.stringify(record, null, 2) + '\n');
   } catch (error) {
     if (error instanceof CoreTaskError) throw error;
     fail('IRIS_TASK_WRITE_FAILED', 'Task 无法安全写入');
@@ -169,7 +172,7 @@ function safeError(error, overrides) {
   return providerErrorRecord(error, overrides);
 }
 
-export function createCoreTask(dataRoot, input = {}) {
+function newTaskRecord(input, id) {
   const capability = String(input.capability || '').trim();
   if (!CAPABILITIES.has(capability)) fail('IRIS_TASK_INPUT_INVALID', 'Task capability 无效');
   const retriedFrom = input.retriedFrom === undefined ? undefined : String(input.retriedFrom);
@@ -177,10 +180,10 @@ export function createCoreTask(dataRoot, input = {}) {
   const sourceArtifactId = input.sourceArtifactId;
   if (sourceArtifactId !== undefined && (capability !== 'image' || !ARTIFACT_ID.test(sourceArtifactId))) fail('IRIS_TASK_INPUT_INVALID', '改图 sourceArtifactId 必须是合法 Artifact ID');
   const now = new Date().toISOString();
-  return writeRecord(dataRoot, {
+  return {
     schemaVersion: 0,
     semanticsVersion: 2,
-    id: 'task_' + crypto.randomBytes(12).toString('hex'),
+    id,
     capability,
     status: 'running',
     phase: 'queued',
@@ -197,7 +200,50 @@ export function createCoreTask(dataRoot, input = {}) {
     // D4 retry as new task：显式单向关系（新任务指向旧任务），绝不复制 Prompt。
     ...(retriedFrom !== undefined ? { retriedFrom } : {}),
     ...(sourceArtifactId !== undefined ? { sourceArtifactId } : {})
-  });
+  };
+}
+
+export function createCoreTask(dataRoot, input = {}) {
+  return writeRecord(dataRoot, newTaskRecord(input, 'task_' + crypto.randomBytes(12).toString('hex')));
+}
+
+/** Flow 只能接回自己持久预留的 Task；原有 Task 没有该字段，读取语义不变。 */
+export function assertFlowTaskMatches(task, run) {
+  const providerId = parseModelRef(run.input.model_ref).providerId;
+  if (task.id !== run.edit.taskId || task.capability !== 'image' || task.sourceArtifactId !== run.source.artifactId
+      || !validFlowBinding(task.flowBinding) || task.flowBinding.runId !== run.id
+      || task.flowBinding.inputDigest !== run.inputDigest
+      || task.attempts.some(attempt => attempt.providerId !== providerId
+        || attempt.model !== run.input.model_ref || attempt.providerBinding !== run.providerBinding)
+      || (task.attempts.length && (task.providerId !== providerId || task.modelRef !== run.input.model_ref || task.providerBinding !== run.providerBinding))) {
+    fail('IRIS_FLOW_TASK_CONFLICT', '流程与原 Task 的身份、输入或模型绑定冲突');
+  }
+  return task;
+}
+
+export function findFlowTask(dataRoot, run) {
+  for (const relative of [STORE_DIR, STORE_DIR + '/' + STORE_VERSION, STORE_DIR + '/' + STORE_VERSION + '/tasks']) {
+    try {
+      const stat = fs.lstatSync(path.join(dataRoot, relative));
+      if (!stat.isDirectory() || stat.isSymbolicLink()) fail('IRIS_FLOW_TASK_CONFLICT', '流程 Task 目录不安全');
+    } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  try { fs.lstatSync(taskFile(dataRoot, run.edit.taskId)); }
+  catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    if (run.edit.claimed) fail('IRIS_FLOW_TASK_CONFLICT', '流程已建立的 Task 丢失，禁止重建或重新生成');
+    return null;
+  }
+  return assertFlowTaskMatches(readRecord(dataRoot, run.edit.taskId), run);
+}
+
+/** 仅从已提交的 Run 读取 ID；排他发布，新旧身份均不能覆盖。 */
+export function claimFlowTask(dataRoot, runId) {
+  const run = readFlowRun(dataRoot, runId);
+  const previous = findFlowTask(dataRoot, run);
+  if (previous) return previous;
+  return writeRecord(dataRoot, { ...newTaskRecord({ capability: 'image', sourceArtifactId: run.source.artifactId }, run.edit.taskId),
+    flowBinding: flowTaskBinding(run) }, true);
 }
 
 export function inspectCoreTask(dataRoot, id) {
@@ -366,7 +412,7 @@ export function activateCoreWatch(dataRoot, taskId) {
   });
 }
 
-export function recordCorePollResult(dataRoot, taskId, result) {
+export function recordCorePollResult(dataRoot, taskId, result, { deliveryCache = false } = {}) {
   return mutate(dataRoot, taskId, (task) => {
     if (task.acceptance !== 'accepted' || !task.remoteTaskId) {
       fail('IRIS_TASK_NOT_OBSERVABLE', 'Task 缺少可观察的远端受理事实');
@@ -387,6 +433,7 @@ export function recordCorePollResult(dataRoot, taskId, result) {
       task.phase = 'running';
       task.outcome = 'succeeded';
       task.deliveryState = 'pending';
+      if (deliveryCache) task.deliveryCache = true;
       delete task.lastError;
       return;
     }
@@ -524,6 +571,13 @@ export function recordCoreCancelResult(dataRoot, taskId, result) {
  */
 export function recoverCoreTask(dataRoot, taskId) {
   let current = readRecord(dataRoot, taskId);
+  // Flow 的异步完成结果同样先缓存，再记录 poll；中断时只恢复原结果，不重新查询/生成。
+  if (current.flowBinding && current.acceptance === 'accepted' && current.remoteTaskId
+      && current.outcome === 'none' && current.cancelState === 'none'
+      && readDeliveryCache(dataRoot, current, { allowAbsent: true })) {
+    recordCorePollResult(dataRoot, taskId, { kind: 'succeeded' }, { deliveryCache: true });
+    current = readRecord(dataRoot, taskId);
+  }
   if (current.phase === 'submitting' && current.acceptance === 'none') {
     const cache = readDeliveryCache(dataRoot, current, { allowAbsent: true });
     if (cache) {