@mokuyoaxis/dsh-iris 0.2.2 → 0.2.4

package/lib/config.js

@@ -11,7 +11,7 @@ import os from 'node:os';
 import * as cap from './capability.js';
 import * as models from './models.js';
 import { atomicWritePrivate, chmodPrivateFile, privateSibling } from './private-storage.js';
-import { selectMediaProtocol, selectImageProtocol, normalizeImageProtocol, isConfiguredProvider } from './provider-protocol.js';
+import { selectMediaProtocol, selectImageProtocol, normalizeImageProtocol, normalizeMusicProtocol, isConfiguredProvider } from './provider-protocol.js';
 import { redactProviderMessage } from './provider-contract.js';
 import {
   PROVIDER_HEALTH_FRESH_MS,
@@ -183,37 +183,29 @@ export function providerById(id) {
 const FIELD_OF = models.CAP_FIELD;
 
 /**
- * 严格选择（阶段 6 模型池）：优先用「已分配模型」（有序列表取第一个可用），
- * 否则从全局模型池挑第一个有能力标签的模型。
+ * 严格选择：仅从功能分配名单取第一个可用模型。
  * 返回该模型所属 provider 的副本，并把该能力的模型字段设为选中模型。
  * 向后兼容：调用方继续读 provider.apiKey / provider.imageModel 等。
  * 无可用模型 → null（不再兜底到任意 provider）。
  */
 export function pickFor(capability) {
-  const pool = models.modelPool(providers());
-  let m = null;
-  for (const ref of assignmentOrder(capability)) {
-    m = pool.find((x) => !x.rateLimited && x.ref === ref && x.capabilities.includes(capability));
-    if (m) break;
-  }
-  if (!m) m = models.pickModel(pool, capability);
-  if (!m) return null;
-  const p = providerById(m.providerId);
-  if (!p) return null;
-  const field = FIELD_OF[capability];
-  return field ? { ...p, [field]: m.id } : p;
+  return pickAllFor(capability)[0] || null;
 }
 
 /**
  * 同一能力的有序 provider 列表（供 failover 依次尝试）：
- * 已分配顺序优先（阶段 6 条目 4），其余按池顺序补齐（去重）。
+ * 只使用已分配顺序，不补入全局池。
  * 一个 provider 若池里有多个该能力模型，会返回多条（各自带不同模型）。
  */
 export function pickAllFor(capability, { includeRateLimited = false } = {}) {
-  const pool = models.modelPool(providers());
+  const pool = models.modelPool(providers(), { includeHostVision: true });
   const chosen = models.orderedModels(pool, capability, assignments()[capability], { includeRateLimited });
   const out = [];
   for (const m of chosen) {
+    if (m.ref === models.HOST_VISION_REF) {
+      out.push({ id: models.HOST_VISION_REF, visionModel: m.id });
+      continue;
+    }
     const p = providerById(m.providerId);
     if (!p) continue;
     const field = FIELD_OF[capability];
@@ -233,11 +225,12 @@ const resolveAssignment = models.resolvePoolModel;
 export function assignmentOrder(capability) {
   const a = assignments()[capability];
   if (!a) return [];
-  const pool = models.modelPool(providers());
+  const pool = models.modelPool(allProviders(), { includeHostVision: true });
   const refs = [];
   for (const raw of (Array.isArray(a) ? a : [a])) {
     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);
   }
   return refs;
 }
@@ -245,7 +238,7 @@ export function assignmentOrder(capability) {
 /** 设置某能力分配的模型 id（需在全局池中存在且具备该能力） */
 export function setAssignment(capability, ref) {
   const c = load();
-  const pool = models.modelPool(providers());
+  const pool = models.modelPool(allProviders(), { includeHostVision: true });
   const m = resolveAssignment(pool, ref, capability);
   if (!m) return false;
   if (!c.assignments) c.assignments = {};
@@ -256,7 +249,7 @@ export function setAssignment(capability, ref) {
 
 /**
  * 设置某能力的有序 failover 列表（阶段 6 条目 4）：每个模型须在全局池中存在且具备该能力。
- * 空数组 = 清除分配（回退池顺序自动选择）。重复 id 自动去重。
+ * 空数组 = 未分配，不自动选择。重复 id 自动去重。
  */
 export function setAssignmentOrder(capability, modelRefs) {
   const c = load();
@@ -268,7 +261,7 @@ export function setAssignmentOrder(capability, modelRefs) {
     }
     return true;
   }
-  const pool = models.modelPool(providers());
+  const pool = models.modelPool(allProviders(), { includeHostVision: true });
   const refs = [];
   for (const raw of modelRefs) {
     const m = resolveAssignment(pool, raw, capability);
@@ -281,7 +274,7 @@ export function setAssignmentOrder(capability, modelRefs) {
   return true;
 }
 
-/** 清除某个能力的手动分配（回退到池自动选择） */
+/** 清除功能分配；此后不再发起该功能的新调用。 */
 export function clearAssignment(capability) {
   const c = load();
   if (c.assignments && c.assignments[capability]) {
@@ -451,7 +444,8 @@ export function providerHealthSnapshot({ now = Date.now() } = {}) {
   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 = modelHealth(provider.id, modelId, capability, { now });
+      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 status = aggregateHealthStates(candidates.map((item) => item.status));
@@ -489,6 +483,7 @@ export function upsert(provider) {
   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) } : {}),
+    ...(model?.musicProtocol !== undefined ? { musicProtocol: normalizeMusicProtocol(model.musicProtocol) } : {}),
     ...(model?.visionInput !== undefined ? { visionInput: normalizeVisionInputLimits(model.visionInput) || null } : {}) }));
   if (id) {
     const i = c.providers.findIndex((p) => p.id === id);
@@ -541,6 +536,7 @@ export function setProviderModels(id, modelEntries) {
     p.models = modelEntries.map((m) => {
       const entry = typeof m === 'string' ? { id: m } : { id: m.id, capabilities: m.capabilities,
         ...(m.imageProtocol !== undefined ? { imageProtocol: normalizeImageProtocol(m.imageProtocol) } : {}),
+        ...(m.musicProtocol !== undefined ? { musicProtocol: normalizeMusicProtocol(m.musicProtocol) } : {}),
         ...(m.visionInput !== undefined ? { visionInput: normalizeVisionInputLimits(m.visionInput) || null } : {}) };
       const old = prev.get(entry.id);
       if (old) {
@@ -548,6 +544,7 @@ export function setProviderModels(id, modelEntries) {
         if (old.source) entry.source = old.source;
         if (old.source === 'manual' && Array.isArray(old.capabilities)) entry.capabilities = old.capabilities;
         if (m?.imageProtocol === undefined && old.imageProtocol !== undefined) entry.imageProtocol = old.imageProtocol;
+        if (m?.musicProtocol === undefined && old.musicProtocol !== undefined) entry.musicProtocol = old.musicProtocol;
         if (m?.visionInput === undefined && old.visionInput !== undefined) entry.visionInput = old.visionInput;
       }
       if (m && m.verified) entry.verified = m.verified;
@@ -590,6 +587,9 @@ function findModelEntry(p, modelId) {
 
 function resetChangedImageProtocolHealth(previous, next) {
   for (const model of models.providerModels(previous)) {
+    if (model.musicProtocol !== models.providerModels(next).find(item => item.id === model.id)?.musicProtocol) {
+      clearModelCapabilityHealth(next, model.id, cap.CAPABILITIES.MUSIC);
+    }
     if (selectImageProtocol(previous, model.id).mediaProtocol !== selectImageProtocol(next, model.id).mediaProtocol) {
       clearModelCapabilityHealth(next, model.id, cap.CAPABILITIES.IMAGE);
     }
@@ -615,6 +615,24 @@ export function setModelImageProtocol(id, modelId, value) {
   return true;
 }
 
+/** 音乐协议独立绑定到已配置模型，不覆盖账号生图协议。 */
+export function setModelMusicProtocol(id, modelId, value) {
+  const protocol = normalizeMusicProtocol(value);
+  const provider = load().providers.find(item => item.id === id);
+  if (!provider) return false;
+  const entries = Array.isArray(provider.models) ? provider.models
+    : models.providerModels(provider).map(({ id, capabilities }) => ({ id, capabilities }));
+  const index = entries.findIndex(model => (typeof model === 'string' ? model : model?.id)?.trim() === modelId);
+  if (index < 0) return false;
+  const entry = typeof entries[index] === 'string' ? { id: entries[index] } : entries[index];
+  entries[index] = entry;
+  provider.models = entries;
+  if (entry.musicProtocol !== protocol) clearModelCapabilityHealth(provider, modelId, cap.CAPABILITIES.MUSIC);
+  entry.musicProtocol = protocol;
+  persist();
+  return true;
+}
+
 /** 看图预算变更不会伪造实测成功、解除额度停用或改写原图。 */
 export function setModelVisionInput(id, modelId, value) {
   const limits = normalizeVisionInputLimits(value);

package/lib/core-artifact-store.js

@@ -305,20 +305,46 @@ function finishObject(dataRoot, input) {
   const relations = normalizedRelations(input.relations);
   validateRelationTargets(dataRoot, relations);
   const metadata = jsonClone(input.metadata, 'metadata');
-  const id = 'artifact_' + crypto.randomBytes(12).toString('hex');
+  // 同步交付缓存预留的 ID 可重入提交，避免多产物交付或 Task 落盘中断后重复作品。
+  const resumable = input.artifactId !== undefined;
+  const id = resumable ? input.artifactId : 'artifact_' + crypto.randomBytes(12).toString('hex');
+  if (!ID.test(id) || (resumable && (!HASH.test(input.expectedDigest)
+      || !Number.isSafeInteger(input.expectedSize) || input.expectedSize < 1))) {
+    fail('IRIS_ARTIFACT_INPUT_INVALID', '可恢复 Artifact 身份或内容证据无效');
+  }
   const store = ensureStore(dataRoot);
   const objectName = id + extension;
   const object = path.join(store.objects, objectName);
+  const exists = (file) => {
+    try { fs.lstatSync(file); return true; }
+    catch (error) { if (error.code === 'ENOENT') return false; throw error; }
+  };
+  if (resumable && exists(recordPath(dataRoot, id))) {
+    const previous = readArtifact(dataRoot, id).manifest;
+    if (previous.size !== input.expectedSize || previous.digest.value !== input.expectedDigest
+        || previous.kind !== kind || previous.mediaType !== mediaType
+        || JSON.stringify(previous.metadata) !== JSON.stringify(metadata)
+        || JSON.stringify(previous.relations) !== JSON.stringify(relations)) {
+      fail('IRIS_ARTIFACT_INPUT_INVALID', '可恢复 Artifact 与已提交内容不一致');
+    }
+    try { refreshIndex(dataRoot); } catch (_) { /* 不撤销已有提交 */ }
+    return publicArtifact(previous);
+  }
   let stat;
   try {
-    input.writeObject(object);
+    if (resumable && exists(object)) {
+      if (regularFile(object).size !== input.expectedSize || hashFile(object) !== input.expectedDigest) {
+        fail('IRIS_ARTIFACT_INPUT_INVALID', '未提交 Artifact 与恢复内容不一致');
+      }
+    } else input.writeObject(object);
     stat = regularFile(object);
-  } catch (_) {
+  } catch (error) {
+    if (resumable) throw error;
     try { fs.rmSync(object, { force: true }); } catch (_) { /* 当前随机 ID */ }
     fail('IRIS_ARTIFACT_WRITE_FAILED', 'Artifact 对象无法安全写入');
   }
   if (!stat.size) {
-    try { fs.rmSync(object, { force: true }); } catch (_) { /* 只清理当前随机 ID */ }
+    if (!resumable) try { fs.rmSync(object, { force: true }); } catch (_) { /* 只清理当前随机 ID */ }
     fail('IRIS_ARTIFACT_INPUT_INVALID', 'Artifact 内容不能为空');
   }
   const manifest = {
@@ -333,12 +359,23 @@ function finishObject(dataRoot, input) {
     relations,
     metadata
   };
+  if (resumable && (manifest.size !== input.expectedSize || manifest.digest.value !== input.expectedDigest)) {
+    fail('IRIS_ARTIFACT_INPUT_INVALID', 'Artifact 复制结果与恢复内容证据不一致');
+  }
+  if (resumable && exists(manifestPath(dataRoot, id))) {
+    const previous = validateManifest(jsonFile(manifestPath(dataRoot, id)), id);
+    if (JSON.stringify(previous) !== JSON.stringify(manifest)) {
+      fail('IRIS_ARTIFACT_INPUT_INVALID', '未提交 Artifact Manifest 与恢复内容不一致');
+    }
+  }
   try {
     writeManifest(dataRoot, manifest);
     commitRecord(dataRoot, id);
   } catch (_) {
-    try { fs.rmSync(object, { force: true }); } catch (_) { /* 当前 ID */ }
-    try { fs.rmSync(manifestPath(dataRoot, id), { force: true }); } catch (_) { /* 当前 ID */ }
+    if (!resumable) {
+      try { fs.rmSync(object, { force: true }); } catch (_) { /* 当前 ID */ }
+      try { fs.rmSync(manifestPath(dataRoot, id), { force: true }); } catch (_) { /* 当前 ID */ }
+    }
     fail('IRIS_ARTIFACT_WRITE_FAILED', 'Artifact 无法安全提交');
   }
   try { refreshIndex(dataRoot); } catch (_) { /* index 是可重建缓存，不撤销已提交 Artifact */ }
@@ -366,6 +403,7 @@ export function adoptCoreArtifactFile(dataRoot, input = {}) {
   return finishObject(dataRoot, {
     ...input,
     mediaType,
+    ...(input.artifactId ? { expectedSize: stat.size, expectedDigest: hashFile(source) } : {}),
     kind: input.kind || 'adopted',
     writeObject(object) {
       const tmp = privateSibling(object, 'adopt');

package/lib/core-delivery-cache.js

@@ -0,0 +1,145 @@
+'use strict';
+
+/** 同步完成结果的私有交付证据；来源 URL/字节不进入 Task、Manifest 或日志。 */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { atomicWritePrivate, ensurePrivateDir } from './private-storage.js';
+
+const TASK_ID = /^task_[a-f0-9]{24}$/;
+const ARTIFACT_ID = /^artifact_[a-f0-9]{24}$/;
+const PAYLOAD_FILE = /^payload-[a-f0-9]{24}\.bin$/;
+const HASH = /^[a-f0-9]{64}$/;
+
+export class DeliveryCacheError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DeliveryCacheError';
+    this.code = 'IRIS_DELIVERY_CACHE_INVALID';
+  }
+}
+
+function invalid() { throw new DeliveryCacheError('同步交付缓存缺失、损坏或与 Task 身份不一致；不会重新生成'); }
+
+function directory(dataRoot, taskId, create = false) {
+  if (!TASK_ID.test(taskId)) invalid();
+  let current = dataRoot;
+  for (const part of ['delivery-cache', 'v0', taskId]) {
+    current = path.join(current, part);
+    if (create) {
+      try { fs.lstatSync(current); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; ensurePrivateDir(current); }
+    }
+    const stat = fs.lstatSync(current);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) invalid();
+  }
+  return current;
+}
+
+function regular(file) {
+  const stat = fs.lstatSync(file);
+  if (!stat.isFile() || stat.isSymbolicLink()) invalid();
+  return stat;
+}
+
+function fingerprint(file) {
+  const stat = regular(file);
+  if (!stat.size) invalid();
+  const hash = crypto.createHash('sha256');
+  const chunk = Buffer.alloc(1024 * 1024);
+  const fd = fs.openSync(file, 'r');
+  try {
+    let count;
+    while ((count = fs.readSync(fd, chunk, 0, chunk.length, null))) hash.update(chunk.subarray(0, count));
+  } finally { fs.closeSync(fd); }
+  return { size: stat.size, sha256: hash.digest('hex') };
+}
+
+function save(dataRoot, cache) {
+  atomicWritePrivate(path.join(directory(dataRoot, cache.taskId), 'result.json'), JSON.stringify(cache, null, 2) + '\n');
+}
+
+export function createDeliveryCache(dataRoot, task, artifacts) {
+  if (!Array.isArray(artifacts) || !artifacts.length) invalid();
+  const root = directory(dataRoot, task.id, true);
+  try { fs.lstatSync(path.join(root, 'result.json')); invalid(); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  const cache = {
+    schemaVersion: 0, resultKind: 'completed', taskId: task.id, attemptId: task.activeAttemptId,
+    providerId: task.providerId, modelRef: task.modelRef, capability: task.capability,
+    ...(task.providerBinding ? { providerBinding: task.providerBinding } : {}),
+    createdAt: new Date().toISOString(), items: []
+  };
+  for (const remote of artifacts) {
+    const item = { artifactId: 'artifact_' + crypto.randomBytes(12).toString('hex') };
+    if (remote.kind === 'remote-url') {
+      item.source = { kind: 'remote-url', url: remote.url, ...(remote.mediaType ? { mediaType: remote.mediaType } : {}) };
+    } else if (remote.kind === 'inline-base64') {
+      const bytes = Buffer.from(remote.data, 'base64');
+      if (!bytes.length || bytes.toString('base64') !== remote.data) invalid();
+      const file = 'payload-' + crypto.randomBytes(12).toString('hex') + '.bin';
+      atomicWritePrivate(path.join(root, file), bytes);
+      item.payload = { file, size: bytes.length, sha256: crypto.createHash('sha256').update(bytes).digest('hex'),
+        ...(remote.mediaType ? { mediaType: remote.mediaType } : {}) };
+    } else invalid();
+    cache.items.push(item);
+  }
+  // result.json 是完整同步响应的提交证据；未发布的文件不作为可恢复结果。
+  save(dataRoot, cache);
+  return cache;
+}
+
+export function readDeliveryCache(dataRoot, task, { allowAbsent = false } = {}) {
+  let cache;
+  try {
+    const file = path.join(directory(dataRoot, task.id), 'result.json');
+    regular(file);
+    cache = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    if (allowAbsent && error.code === 'ENOENT') return null;
+    invalid();
+  }
+  if (!cache || cache.schemaVersion !== 0 || cache.resultKind !== 'completed'
+      || cache.taskId !== task.id || cache.attemptId !== task.activeAttemptId
+      || cache.providerId !== task.providerId || cache.modelRef !== task.modelRef
+      || cache.capability !== task.capability || cache.providerBinding !== task.providerBinding
+      || !Array.isArray(cache.items) || !cache.items.length
+      || typeof cache.createdAt !== 'string' || !Number.isFinite(Date.parse(cache.createdAt))) invalid();
+  const ids = new Set();
+  for (const item of cache.items) {
+    if (!item || !ARTIFACT_ID.test(item.artifactId) || ids.has(item.artifactId)) invalid();
+    ids.add(item.artifactId);
+    if (item.source && (item.source.kind !== 'remote-url' || typeof item.source.url !== 'string' || !item.source.url.trim()
+        || (item.source.mediaType !== undefined && typeof item.source.mediaType !== 'string'))) invalid();
+    if (item.payload && (!PAYLOAD_FILE.test(item.payload.file) || !HASH.test(item.payload.sha256)
+        || !Number.isSafeInteger(item.payload.size) || item.payload.size < 1
+        || (item.payload.mediaType !== undefined && typeof item.payload.mediaType !== 'string'))) invalid();
+    if (!item.payload && !item.source) invalid();
+  }
+  return cache;
+}
+
+export function deliveryCacheNeedsProvider(dataRoot, task) {
+  return readDeliveryCache(dataRoot, task).items.some(item => !item.payload);
+}
+
+export function newDeliveryPayloadPath(dataRoot, cache) {
+  return path.join(directory(dataRoot, cache.taskId), 'payload-' + crypto.randomBytes(12).toString('hex') + '.bin');
+}
+
+export function recordDeliveryPayload(dataRoot, cache, index, file, mediaType) {
+  const root = directory(dataRoot, cache.taskId);
+  if (path.dirname(file) !== root || !PAYLOAD_FILE.test(path.basename(file))) invalid();
+  cache.items[index].payload = { file: path.basename(file), ...fingerprint(file), mediaType };
+  delete cache.items[index].source;
+  save(dataRoot, cache);
+}
+
+export function readDeliveryPayload(dataRoot, cache, index) {
+  const payload = cache.items[index].payload;
+  const file = path.join(directory(dataRoot, cache.taskId), payload.file);
+  let actual;
+  try { actual = fingerprint(file); } catch (_) { invalid(); }
+  if (actual.size !== payload.size || actual.sha256 !== payload.sha256) invalid();
+  return file;
+}

package/lib/core-maintenance.js

@@ -4,11 +4,12 @@ import crypto from 'node:crypto';
 import { inspectCoreArtifact, refreshCoreArtifactInventory } from './core-artifacts.js';
 import { inspectCoreTask, listCoreTasks } from './core-tasks.js';
 import { atomicWritePrivate } from './private-storage.js';
+import { readDeliveryCache } from './core-delivery-cache.js';
 
 const TASK = /^task_[a-f0-9]{24}$/;
 const ARTIFACT = /^artifact_[a-f0-9]{24}$/;
 const TRANSACTION = /^delete_[a-f0-9]{24}$/;
-const MANAGED = /^(?:task-store\/v0\/tasks\/task_[a-f0-9]{24}\.json|artifact-store\/v0\/(?:records|manifests)\/artifact_[a-f0-9]{24}\.json|artifact-store\/v0\/objects\/artifact_[a-f0-9]{24}\.(?:png|jpg|webp|gif|mp4|webm|wav|mp3|ogg|flac|txt|json)|provider-staging\/v0\/download-[1-9][0-9]*-[a-f0-9]{16}\.part)$/;
+const MANAGED = /^(?:task-store\/v0\/tasks\/task_[a-f0-9]{24}\.json|artifact-store\/v0\/(?:records|manifests)\/artifact_[a-f0-9]{24}\.json|artifact-store\/v0\/objects\/artifact_[a-f0-9]{24}\.(?:png|jpg|webp|gif|mp4|webm|wav|mp3|ogg|flac|txt|json)|provider-staging\/v0\/download-[1-9][0-9]*-[a-f0-9]{16}\.part|delivery-cache\/v0\/task_[a-f0-9]{24}\/(?:result\.json|payload-[a-f0-9]{24}\.bin))$/;
 const fail = (code, message) => { throw Object.assign(new Error(message), { code }); };
 function fileDigest(file) {
   const hash = crypto.createHash('sha256'), chunk = Buffer.allocUnsafe(1024 * 1024), fd = fs.openSync(file, 'r');
@@ -68,6 +69,8 @@ export function planCoreDeletion(root, input) {
     const task = inspectCoreTask(root, id);
     if (task.phase !== 'terminal' || task.acceptance === 'unknown' || task.outcome === 'unknown') blockers.push({ id, reason: 'task_not_settled' });
     files.push(managedFile(root, 'task-store/v0/tasks/' + id + '.json'));
+    const cache = 'delivery-cache/v0/' + id;
+    for (const name of names(root, cache)) files.push(managedFile(root, cache + '/' + name));
   }
   for (const id of artifactIds) {
     inspectCoreArtifact(root, id);
@@ -83,6 +86,11 @@ export function planCoreDeletion(root, input) {
   for (const task of existing.tasks) {
     if (selectedTasks.has(task.id)) continue;
     for (const id of task.artifactIds) if (selectedArtifacts.has(id)) blockers.push({ id, referencedBy: task.id, reason: 'task_artifact_reference' });
+    if (task.deliveryCache && task.deliveryState !== 'ready') {
+      for (const item of readDeliveryCache(root, task).items) {
+        if (selectedArtifacts.has(item.artifactId)) blockers.push({ id: item.artifactId, referencedBy: task.id, reason: 'delivery_cache_reference' });
+      }
+    }
     if (selectedArtifacts.has(task.sourceArtifactId)) blockers.push({ id: task.sourceArtifactId, referencedBy: task.id, reason: 'task_input_reference' });
     if (selectedTasks.has(task.retriedFrom)) blockers.push({ id: task.retriedFrom, referencedBy: task.id, reason: 'retry_reference' });
   }
@@ -109,6 +117,9 @@ export function planCoreCleanup(root, { older_than_ms = 3600000 } = {}) {
   const referenced = new Set(existing.artifacts.map(artifact => artifact.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') {
+    for (const item of readDeliveryCache(root, task).items) referenced.add(item.artifactId);
+  }
   for (const task of existing.tasks) if (task.sourceArtifactId) referenced.add(task.sourceArtifactId);
   for (const name of names(root, 'artifact-store/v0/manifests')) {
     if (/^artifact_[a-f0-9]{24}\.json$/.test(name)) {

package/lib/core-tasks.js

@@ -7,6 +7,7 @@ import { 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';
 
 const STORE_DIR = 'task-store';
 const STORE_VERSION = 'v0';
@@ -14,7 +15,7 @@ const TASK_ID = /^task_[a-f0-9]{24}$/;
 const ARTIFACT_ID = /^artifact_[a-f0-9]{24}$/;
 const ATTEMPT_ID = /^attempt_[a-f0-9]{24}$/;
 const PROVIDER_BINDING = /^sha256:[a-f0-9]{64}$/;
-const CAPABILITIES = new Set(['image', 'video', 'tts', 'transcribe']);
+const CAPABILITIES = new Set(['image', 'video', 'tts', 'music', 'transcribe']);
 const ATTEMPT_SELECTION_REASONS = new Set(['explicit', 'assignment', 'pool']);
 const ATTEMPT_STAGE_TIMESTAMPS = Object.freeze([
   'queuedAt', 'submitStartedAt', 'submittedAt', 'remoteCompletedAt',
@@ -106,6 +107,7 @@ function validateRecord(record, expectedId) {
       || !Array.isArray(record.attempts) || !Array.isArray(record.artifactIds)
       || !Number.isSafeInteger(record.revision) || record.revision < 1
       || typeof record.createdAt !== 'string' || typeof record.updatedAt !== 'string'
+      || (record.deliveryCache !== undefined && record.deliveryCache !== true)
       || (record.providerBinding !== undefined && !PROVIDER_BINDING.test(record.providerBinding))
       || (record.retriedFrom !== undefined && !TASK_ID.test(record.retriedFrom))
       || (record.sourceArtifactId !== undefined && (record.capability !== 'image' || !ARTIFACT_ID.test(record.sourceArtifactId)))) {
@@ -292,6 +294,7 @@ export function beginCoreAttempt(dataRoot, taskId, fields = {}) {
     task.deliveryState = 'none';
     task.cancelState = 'none';
     delete task.remoteTaskId;
+    delete task.deliveryCache;
     delete task.lastError;
   });
   return Object.freeze(clone(created));
@@ -327,6 +330,7 @@ export function recordCoreAttemptResult(dataRoot, taskId, snapshot) {
       task.phase = 'running';
       task.outcome = 'succeeded';
       task.deliveryState = 'pending';
+      if (snapshot.deliveryCache === true) task.deliveryCache = true;
     }
     if (snapshot.remoteTaskId) task.remoteTaskId = String(snapshot.remoteTaskId);
     if (attempt.error) task.lastError = attempt.error;
@@ -436,7 +440,7 @@ export function recordCoreDownloadCompleted(dataRoot, taskId) {
 
 export function prepareCoreRedelivery(dataRoot, taskId) {
   return mutate(dataRoot, taskId, (task) => {
-    if (task.outcome !== 'succeeded' || task.deliveryState !== 'failed' || !task.remoteTaskId) {
+    if (task.outcome !== 'succeeded' || task.deliveryState !== 'failed' || (!task.remoteTaskId && !task.deliveryCache)) {
       fail('IRIS_TASK_NOT_REDELIVERABLE', 'Task 不处于可重新交付状态');
     }
     task.phase = 'running';
@@ -515,11 +519,21 @@ export function recordCoreCancelResult(dataRoot, taskId, result) {
 }
 
 /**
- * 进程在 submit 返回落盘前退出时，没有 remoteTaskId 可以安全观察；恢复只能把
- * 事实收口为受理未知。已经落盘 remoteTaskId 的任务保持可观察，绝不新建 Attempt。
+ * 同步完整缓存可补回尚未落盘的完成事实；否则提交中断仍收口为受理未知。
+ * 已有 remoteTaskId 的任务保持可观察。恢复不重新提交，也不自动交付缓存。
  */
 export function recoverCoreTask(dataRoot, taskId) {
-  const current = readRecord(dataRoot, taskId);
+  let current = readRecord(dataRoot, taskId);
+  if (current.phase === 'submitting' && current.acceptance === 'none') {
+    const cache = readDeliveryCache(dataRoot, current, { allowAbsent: true });
+    if (cache) {
+      recordCoreAttemptResult(dataRoot, taskId, {
+        id: cache.attemptId, providerId: cache.providerId, model: cache.modelRef,
+        acceptance: 'accepted', resultKind: 'completed', deliveryCache: true
+      });
+      current = readRecord(dataRoot, taskId);
+    }
+  }
   if (current.cancelState === 'requested') {
     return mutate(dataRoot, taskId, (task) => {
       task.phase = 'terminal';

package/lib/core-user-projection.js

@@ -79,7 +79,7 @@ export function coreTaskObservable(task) {
 }
 
 /**
- * 与 task.redeliver 同一组交付事实门：远端已成功、产物取回失败、远端 ID 仍在。
+ * 与 task.redeliver 同一组交付事实门：远端已成功、交付失败，有远端 ID 或同步缓存。
  * 只读持久化事实轴，不解析 Provider、不接触网络；binding 与能力校验仍在
  * Command Service。五类状态里只有 delivery_failed 会标记 redeliverable。
  */
@@ -87,7 +87,7 @@ export function coreTaskRedeliverable(task) {
   if (!task || typeof task !== 'object' || Array.isArray(task)) return false;
   return String(task.outcome || '') === 'succeeded'
     && String(task.deliveryState || '') === 'failed'
-    && Boolean(String(task.remoteTaskId || '').trim());
+    && (Boolean(String(task.remoteTaskId || '').trim()) || task.deliveryCache === true);
 }
 
 /**

package/lib/doctor.js

@@ -1,6 +1,7 @@
 'use strict';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
+import { isSupportedDshVersion, SUPPORTED_DSH_VERSIONS } from './dsh-compatibility.js';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
@@ -331,13 +332,6 @@ function summarizeChecks(checks) {
   };
 }
 
-function dshVersionSupported(value) {
-  /* 当前 0.2 候选只支持经真实安装服务隔离验收的准确 rc.2。
-     Iris 0.1.4 的旧宿主窗口保留在历史发行中，不用于放行当前源码。 */
-  const version = String(value || '').trim().replace(/\s+/g, '');
-  return /^0\.2\.0-rc\.2(?:\+.*)?$/.test(version);
-}
-
 function names(value) {
   return [...new Set((Array.isArray(value) ? value : []).map((item) => String(item || '').trim()).filter(Boolean))];
 }
@@ -379,12 +373,12 @@ export function hostDoctor(host, evidence = {}, options = {}) {
   if (snapshot.host.id === 'deepseek-harness') {
     if (snapshot.host.version === 'unknown') {
       checks.push(result('dsh-version', 'warn', '无法从当前进程识别 DSH 版本',
-        '使用 dsh --version 核对；当前候选仅支持 DSH 0.2.0-rc.2。'));
-    } else if (dshVersionSupported(snapshot.host.version)) {
+        '使用 dsh --version 核对；已验证版本为 DSH ' + SUPPORTED_DSH_VERSIONS.join('、') + '。'));
+    } else if (isSupportedDshVersion(snapshot.host.version)) {
       checks.push(result('dsh-version', 'ok', 'DSH ' + snapshot.host.version + ' 位于已验证支持范围'));
     } else {
       checks.push(result('dsh-version', 'error', 'DSH ' + snapshot.host.version + ' 超出已验证支持范围',
-        '当前候选需要 DSH 0.2.0-rc.2；旧 DSH 0.1.2 线或 0.1.5-rc.1 使用 Iris @mokuyoaxis/dsh-iris@0.1.4。其他版本须另行验收。'));
+        '当前支持 DSH ' + SUPPORTED_DSH_VERSIONS.join('、') + '；旧 DSH 0.1.2 线或 0.1.5-rc.1 使用 Iris @mokuyoaxis/dsh-iris@0.1.4。其他版本须另行验收。'));
     }
   }
 

package/lib/dsh-compatibility.js

@@ -0,0 +1,10 @@
+'use strict';
+
+/** 已完成宿主接口验收的版本；manifest/Doctor/验收脚本共用同一边界。 */
+export const SUPPORTED_DSH_VERSIONS = Object.freeze(['0.2.0-rc.2', '0.2.1-alpha.4']);
+export const DSH_SUPPORT_RANGE = SUPPORTED_DSH_VERSIONS.join(' || ');
+
+export function isSupportedDshVersion(value) {
+  const version = String(value || '').trim().split('+')[0];
+  return SUPPORTED_DSH_VERSIONS.includes(version);
+}

package/lib/dsh-core-adapter.js

@@ -2,7 +2,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { allProviders, irisHome, recordRateLimit } from './config.js';
+import { allProviders, assignments, irisHome, recordRateLimit } from './config.js';
 import { createCommandService } from './command-service.js';
 import { createCoreArtifact, inspectCoreArtifact, listCoreArtifacts, listCoreArtifactMetadata, readCoreArtifactBytes } from './core-artifacts.js';
 import { createCoreRuntime } from './core-runtime.js';
@@ -15,7 +15,8 @@ import { requireHostPort } from './host-contract.js';
 import { createProviderTaskRunner } from './provider-task-runner.js';
 import { createConfiguredProviderAdapter as createProviderAdapter } from './provider-adapters.js';
 import { parseModelRef } from './models.js';
-import { imageCandidatesFromCatalog, providerForTaskFromCatalog, providerTaskBinding, transcribeCandidatesFromCatalog, ttsCandidatesFromCatalog, videoCandidatesFromCatalog } from './provider-catalog.js';
+import { imageCandidatesFromCatalog, musicCandidatesFromCatalog, providerForTaskFromCatalog, providerTaskBinding, transcribeCandidatesFromCatalog, ttsCandidatesFromCatalog, videoCandidatesFromCatalog } from './provider-catalog.js';
+import { generateMusicTask } from './music-generation.js';
 
 let writerTail = Promise.resolve();
 const providerWatchers = new Map();
@@ -67,6 +68,12 @@ function withReader(callback, signal) {
   return withRuntime('reader', callback, signal);
 }
 
+/** 本地图片与会话附件都交给同一导入Command，不创建生成任务。 */
+export function importImageForDsh(input = {}) {
+  return withWriter((_runtime, commands) => commands.execute('artifact.import', input.imageBytes !== undefined
+    ? { image_bytes: input.imageBytes } : { image_path: input.imagePath }), input.signal);
+}
+
 /**
  * 将 DSH 图片输入投影到共享 crop Command，再把中性 Artifact 读成宿主可保存的字节。
  * bytes 输入先成为 host-input Artifact，输出通过 derived-from 保留关系。
@@ -179,6 +186,13 @@ export function submitProviderTaskForDsh(input = {}) {
   }), input.signal);
 }
 
+export function submitMusicForDsh(input) {
+  return withWriter(runtime => generateMusicTask({
+    runner: createProviderTaskRunner(runtime), candidates: input.candidates,
+    providerInput: input.providerInput, options: input.musicOptions, signal: input.signal
+  }), input.signal);
+}
+
 /** 单步观察已经受理的 Core Task；不会自动循环，也不会创建第二次 submit。 */
 export function observeProviderTaskForDsh(input = {}) {
   return withWriter((runtime) => createProviderTaskRunner(runtime).observe(
@@ -221,7 +235,7 @@ export function reobserveProviderTaskForDsh(input = {}) {
 
 /**
  * D2 人工 redeliver：只对 outcome=succeeded / deliveryState=failed 的 Task
- * 重新取回远端产物（re-poll 产物清单 → download → 新 Artifact），绝不 submit、
+ * 重新交付原结果（同步读缓存，异步 re-poll → download），绝不 submit、
  * 绝不重新生成。
  */
 export function redeliverProviderTaskForDsh(input = {}) {
@@ -277,12 +291,14 @@ export function retryProviderTaskForDsh(input = {}) {
   return withWriter(async (runtime) => {
     const commands = createCommandService(runtime, {
       resolveTaskCandidates: ({ capability, modelRef }) => {
-        const catalog = { providers: allProviders() };
+        const catalog = { providers: allProviders(), assignments: assignments() };
         const ref = modelRef || undefined;
         const candidates = capability === 'video'
           ? videoCandidatesFromCatalog(catalog, ref)
           : capability === 'tts'
             ? ttsCandidatesFromCatalog(catalog, ref)
+            : capability === 'music'
+              ? musicCandidatesFromCatalog(catalog, ref)
             : capability === 'transcribe'
               ? transcribeCandidatesFromCatalog(catalog, ref)
               : imageCandidatesFromCatalog(catalog, ref);