@mokuyoaxis/dsh-iris 0.1.3 → 0.2.0

package/lib/provider-protocol.js

@@ -2,18 +2,54 @@
 /** 供应商媒体协议判断与 DashScope 凭据边界。 */
 
 const DASH_SCOPE_HOST = /^dashscope(?:-[a-z0-9-]+)?\.aliyuncs\.com$/i;
+const REGIONAL_HOST = /^cn-hongkong\.dashscope\.aliyuncs\.com$/i;
+const WORKSPACE_HOST = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.(?:cn-beijing|ap-southeast-1|eu-central-1|ap-northeast-1|us-east-1)\.maas\.aliyuncs\.com$/i;
+
+/** 可选媒体端点；空值沿用普通/视觉端点。 */
+export function providerMediaBaseUrl(provider) {
+  return String(provider?.mediaBaseUrl || '').trim() || String(provider?.baseUrl || '').trim();
+}
 
 export function isDashScopeBaseUrl(value) {
   try {
     const url = new URL(String(value || '').trim());
-    return url.protocol === 'https:' && !url.username && !url.password && DASH_SCOPE_HOST.test(url.hostname);
+    return url.protocol === 'https:' && !url.username && !url.password
+      && (DASH_SCOPE_HOST.test(url.hostname) || REGIONAL_HOST.test(url.hostname) || WORKSPACE_HOST.test(url.hostname));
   } catch (_) {
     return false;
   }
 }
 
 export function inferMediaProtocol(baseUrl) {
-  return isDashScopeBaseUrl(baseUrl) ? 'dashscope' : 'openai-images';
+  return detectMediaProtocol(baseUrl) || 'openai-images';
+}
+
+/** 未识别的端点不等于已验证的兼容协议。 */
+export function detectMediaProtocol(baseUrl) {
+  if (isDashScopeBaseUrl(baseUrl)) return 'dashscope';
+  try {
+    const url = new URL(String(baseUrl || '').trim());
+    if (url.protocol === 'https:' && !url.username && !url.password
+        && url.hostname === 'api.openai.com') return 'openai-images';
+  } catch (_) { /* 未知端点保留兼容回退，由调用方展示推断状态 */ }
+  return null;
+}
+
+export function selectMediaProtocol(provider) {
+  const explicit = typeof provider?.mediaProtocol === 'string' ? provider.mediaProtocol.trim() : '';
+  if (explicit && explicit !== 'auto'
+      && (provider?.protocolInferred !== true || explicit !== 'openai-images')) {
+    return { mediaProtocol: explicit, protocolInferred: false };
+  }
+  const detected = detectMediaProtocol(providerMediaBaseUrl(provider));
+  return { mediaProtocol: detected || 'openai-images', protocolInferred: !detected };
+}
+
+export function unsupportedProtocolError(protocol, kind = 'media') {
+  const safeName = /^[a-z][a-z0-9-]{0,63}$/.test(String(protocol)) ? protocol : '(invalid)';
+  const error = new TypeError('iris: 不支持的 ' + (kind === 'vision' ? 'Vision' : 'Provider') + ' 协议：' + safeName);
+  error.code = kind === 'vision' ? 'IRIS_VISION_PROTOCOL_UNSUPPORTED' : 'IRIS_PROVIDER_PROTOCOL_UNSUPPORTED';
+  return error;
 }
 
 /** 返回官方 DashScope API 根；不满足边界时在 fetch 前拒绝。 */
@@ -23,3 +59,16 @@ export function dashscopeApiBase(baseUrl) {
   }
   return new URL('/api/v1', String(baseUrl).trim()).toString().replace(/\/$/, '');
 }
+
+/** 无认证模式不发送保留的旧凭据；未声明模式保持 bearer 兼容。 */
+export function providerApiKey(provider) {
+  return provider?.auth === 'none' ? '' : String(provider?.apiKey || '');
+}
+
+/** 配置管理与 headless 候选链共用可用性门，未声明 enabled 时默认启用。 */
+export function isConfiguredProvider(provider) {
+  return Boolean(provider && provider.enabled !== false
+    && typeof provider.id === 'string' && provider.id.trim()
+    && providerMediaBaseUrl(provider)
+    && (provider.auth === 'none' || (typeof provider.apiKey === 'string' && provider.apiKey.trim())));
+}

package/lib/provider-task-runner.js

@@ -0,0 +1,328 @@
+'use strict';
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createCoreArtifact } from './core-artifacts.js';
+import {
+  activateCoreWatch,
+  beginCoreAttempt,
+  beginCoreDelivery,
+  completeCoreDelivery,
+  createCoreTask,
+  failCoreDelivery,
+  finalizeCoreNoAcceptance,
+  inspectCoreTask,
+  prepareCoreRedelivery,
+  recordCoreAttemptResult,
+  recordCoreCancelResult,
+  recordCoreDownloadCompleted,
+  recordCorePollResult,
+  recordCoreWatchError,
+  recoverCoreTask,
+  requestCoreCancel
+} from './core-tasks.js';
+import { ensurePrivateDir } from './private-storage.js';
+import { parseModelRef } from './models.js';
+import {
+  hasProviderOperation,
+  invokeProviderOperation
+} from './provider-adapter.js';
+import { providerErrorRecord, submitWithAcceptanceBoundary } from './provider-contract.js';
+
+export const PROVIDER_TASK_RUNNER_VERSION = 0;
+
+/**
+ * 按 capability 冻结的交付 Profile（E 阶段视频迁移）：媒体类型白名单、Artifact
+ * kind 与默认 metadata。新增 capability 必须显式登记；未登记的 capability 直接
+ * 失败，不会按图片语义猜。
+ */
+export const DELIVERY_PROFILES = Object.freeze({
+  image: Object.freeze({ kind: 'generated-image', mediaTypes: Object.freeze(['image/png']), defaultMediaType: 'image/png' }),
+  video: Object.freeze({ kind: 'generated-video', mediaTypes: Object.freeze(['video/mp4']), defaultMediaType: 'video/mp4' }),
+  // TTS 同步完成型：submit 内 completed → 同一次调用直接交付（无 remote 长轮询）。
+  tts: Object.freeze({ kind: 'generated-audio', mediaTypes: Object.freeze(['audio/mpeg', 'audio/wav']), defaultMediaType: 'audio/mpeg' }),
+  // 转写上传型异步：受理 + remoteTaskId → 长轮询 → 文本物化为 UTF-8 Artifact。
+  transcribe: Object.freeze({ kind: 'transcript', mediaTypes: Object.freeze(['text/plain']), defaultMediaType: 'text/plain' })
+});
+const runtimeTaskGates = new WeakMap();
+
+export class ProviderTaskRunnerError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'ProviderTaskRunnerError';
+    this.code = code;
+  }
+}
+
+function checkRuntime(runtime) {
+  if (!runtime || typeof runtime.run !== 'function') {
+    throw new TypeError('Provider Task Runner 需要已创建的 Core Runtime');
+  }
+}
+
+function checkAdapterForTask(task, adapter) {
+  if (!adapter || adapter.id !== task.providerId) {
+    throw new ProviderTaskRunnerError('IRIS_PROVIDER_TASK_IDENTITY_MISMATCH', 'Provider Adapter 与 Task 已持久化身份不一致');
+  }
+  return adapter;
+}
+
+function normalizedCandidates(capability, candidates) {
+  if (!Array.isArray(candidates) || !candidates.length) throw new TypeError('至少需要一个 Provider 候选');
+  return candidates.map((candidate, index) => {
+    const adapter = candidate?.adapter;
+    const model = String(candidate?.model || '').trim();
+    const parsed = parseModelRef(model);
+    const selectionReason = candidate?.selectionReason;
+    if (!adapter || !adapter.capabilities?.includes(capability) || !parsed
+        || parsed.providerId !== adapter.id || !parsed.modelId
+        || (candidate.providerBinding !== undefined && !/^sha256:[a-f0-9]{64}$/.test(candidate.providerBinding))
+        || (selectionReason !== undefined && !['explicit', 'assignment', 'pool'].includes(selectionReason))) {
+      throw new TypeError('Provider 候选 ' + (index + 1) + ' 不支持 Task capability 或模型复合身份无效');
+    }
+    return { adapter, model, providerModel: parsed.modelId, providerBinding: candidate.providerBinding, selectionReason };
+  });
+}
+
+function stagingFile(dataRoot) {
+  const directory = path.join(dataRoot, 'provider-staging', 'v0');
+  ensurePrivateDir(directory);
+  return path.join(directory, 'download-' + process.pid + '-' + crypto.randomBytes(8).toString('hex') + '.part');
+}
+
+async function deliverArtifacts(dataRoot, taskId, adapter, remoteArtifacts, signal) {
+  beginCoreDelivery(dataRoot, taskId);
+  const artifactIds = [];
+  const stagedFiles = [];
+  try {
+    if (!Array.isArray(remoteArtifacts) || remoteArtifacts.length === 0) {
+      throw Object.assign(new Error('Provider Task Runner 没有收到可物化产物'), {
+        stage: 'download', category: 'protocol', acceptance: 'accepted'
+      });
+    }
+    const task = inspectCoreTask(dataRoot, taskId);
+    const profile = DELIVERY_PROFILES[task.capability];
+    if (!profile) {
+      throw Object.assign(new Error('Provider Task Runner 没有该 capability 的交付 Profile：' + task.capability), {
+        stage: 'download', category: 'protocol', acceptance: 'accepted'
+      });
+    }
+    for (const remote of remoteArtifacts) {
+      const mediaType = String(remote.mediaType || profile.defaultMediaType);
+      if (!profile.mediaTypes.includes(mediaType)) {
+        throw Object.assign(new Error('Provider Task Runner 交付媒体类型不在 Profile 白名单：' + mediaType), {
+          stage: 'download', category: 'protocol', acceptance: 'accepted'
+        });
+      }
+      const target = stagingFile(dataRoot);
+      stagedFiles.push({ target, mediaType });
+      const downloaded = await invokeProviderOperation(adapter, 'download', {
+        capability: task.capability,
+        artifact: remote,
+        targetPath: target,
+        signal
+      }, { signal, taskId });
+      const stat = fs.lstatSync(target);
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.size !== downloaded.bytes) {
+        throw Object.assign(new Error('Provider 物化结果与文件证据不一致'), {
+          stage: 'download', category: 'local_io', acceptance: 'accepted'
+        });
+      }
+    }
+    recordCoreDownloadCompleted(dataRoot, taskId);
+    for (const staged of stagedFiles) {
+      const artifact = createCoreArtifact(dataRoot, {
+        kind: profile.kind,
+        mediaType: staged.mediaType,
+        bytes: fs.readFileSync(staged.target),
+        metadata: { taskId, capability: task.capability }
+      });
+      artifactIds.push(artifact.id);
+    }
+    return completeCoreDelivery(dataRoot, taskId, artifactIds);
+  } catch (error) {
+    return failCoreDelivery(dataRoot, taskId, error);
+  } finally {
+    for (const staged of stagedFiles) {
+      try { fs.rmSync(staged.target, { force: true }); } catch (_) { /* 后续显式清理可处理残留 */ }
+    }
+  }
+}
+
+async function observeWithinRoot(dataRoot, taskId, adapter, signal) {
+  const before = inspectCoreTask(dataRoot, taskId);
+  checkAdapterForTask(before, adapter);
+  activateCoreWatch(dataRoot, taskId);
+  let result;
+  try {
+    result = await invokeProviderOperation(adapter, 'poll', {
+      capability: before.capability,
+      remoteTaskId: before.remoteTaskId,
+      signal
+    }, { signal, taskId });
+  } catch (error) {
+    return recordCoreWatchError(dataRoot, taskId, error);
+  }
+  const recorded = recordCorePollResult(dataRoot, taskId, result);
+  if (result.kind !== 'succeeded') return recorded;
+  return deliverArtifacts(dataRoot, taskId, adapter, result.artifacts, signal);
+}
+
+/**
+ * FakeProvider 与未来真实 Host 共用的生命周期调度候选。它不拥有 timer，也不会
+ * 自动循环轮询；每次 observe 只消费一个 poll 结果，使重启和故障边界可重复验证。
+ */
+export function createProviderTaskRunner(runtime) {
+  checkRuntime(runtime);
+  let activeTasks = runtimeTaskGates.get(runtime);
+  if (!activeTasks) {
+    activeTasks = new Set();
+    runtimeTaskGates.set(runtime, activeTasks);
+  }
+
+  async function runExclusive(taskId, operation, callback) {
+    const key = String(taskId || '');
+    if (activeTasks.has(key)) {
+      throw new ProviderTaskRunnerError(
+        'IRIS_PROVIDER_TASK_BUSY',
+        '该 Task 已有生命周期操作正在执行'
+      );
+    }
+    activeTasks.add(key);
+    try {
+      return await runtime.run(operation, callback);
+    } finally {
+      activeTasks.delete(key);
+    }
+  }
+
+  async function submit(input = {}) {
+    return runtime.run('execute', async ({ dataRoot, signal }) => {
+      const capability = String(input.capability || '').trim();
+      const candidates = normalizedCandidates(capability, input.candidates);
+      const task = createCoreTask(dataRoot, { capability, retriedFrom: input.retriedFrom });
+      const wrapped = candidates.map(({ adapter, model, providerModel }) => ({
+        id: adapter.id,
+        model,
+        adapter,
+        submit: (providerInput, context) => invokeProviderOperation(
+          adapter,
+          'submit',
+          { capability, model: providerModel, input: providerInput, signal },
+          { ...context, signal, taskId: task.id }
+        )
+      }));
+      const submitted = await submitWithAcceptanceBoundary(wrapped, input.providerInput ?? {}, {
+        beforeAttempt: async (attempt) => {
+          const candidate = candidates[attempt.ordinal - 1];
+          return beginCoreAttempt(dataRoot, task.id, {
+            ...attempt,
+            ...(candidate.providerBinding !== undefined ? { providerBinding: candidate.providerBinding } : {}),
+            ...(candidate.selectionReason !== undefined ? { selectionReason: candidate.selectionReason } : {})
+          });
+        },
+        afterResult: async (attempt) => recordCoreAttemptResult(dataRoot, task.id, attempt)
+      });
+      if (submitted.localError) {
+        return Object.freeze({ taskId: task.id, task: inspectCoreTask(dataRoot, task.id), localError: submitted.localError });
+      }
+      if (!submitted.result) throw new Error('Provider 提交流程没有返回结果');
+      if (submitted.result.kind === 'not_accepted') {
+        finalizeCoreNoAcceptance(dataRoot, task.id, submitted.result.error);
+      } else if (submitted.result.kind === 'completed') {
+        const artifacts = submitted.result.artifacts;
+        return Object.freeze({
+          taskId: task.id,
+          task: await deliverArtifacts(dataRoot, task.id, submitted.candidate.adapter, artifacts, signal),
+          attempts: submitted.attempts
+        });
+      }
+      return Object.freeze({
+        taskId: task.id,
+        task: inspectCoreTask(dataRoot, task.id),
+        attempts: submitted.attempts
+      });
+    });
+  }
+
+  function inspect(taskId) {
+    return runtime.run('inspect', ({ dataRoot }) => inspectCoreTask(dataRoot, taskId));
+  }
+
+  function observe(taskId, adapter, { resumeActive = false } = {}) {
+    return runExclusive(taskId, 'execute', ({ dataRoot, signal }) => {
+      if (resumeActive) {
+        const current = inspectCoreTask(dataRoot, taskId);
+        checkAdapterForTask(current, adapter);
+        if (current.watchState === 'active') recoverCoreTask(dataRoot, taskId);
+      }
+      return observeWithinRoot(dataRoot, taskId, adapter, signal);
+    });
+  }
+
+  function redeliver(taskId, adapter) {
+    return runExclusive(taskId, 'execute', async ({ dataRoot, signal }) => {
+      const task = inspectCoreTask(dataRoot, taskId);
+      checkAdapterForTask(task, adapter);
+      prepareCoreRedelivery(dataRoot, taskId);
+      let result;
+      try {
+        result = await invokeProviderOperation(adapter, 'poll', {
+          capability: task.capability,
+          remoteTaskId: task.remoteTaskId,
+          signal
+        }, { signal, taskId, redelivery: true });
+      } catch (error) {
+        return failCoreDelivery(dataRoot, taskId, error);
+      }
+      if (result.kind !== 'succeeded') {
+        return failCoreDelivery(dataRoot, taskId, providerErrorRecord(
+          result.error || '重新查询没有得到可交付产物',
+          { stage: 'download', category: 'protocol', acceptance: 'accepted' }
+        ));
+      }
+      return deliverArtifacts(dataRoot, taskId, adapter, result.artifacts, signal);
+    });
+  }
+
+  function cancel(taskId, adapter) {
+    return runExclusive(taskId, 'execute', async ({ dataRoot, signal }) => {
+      const task = inspectCoreTask(dataRoot, taskId);
+      checkAdapterForTask(task, adapter);
+      requestCoreCancel(dataRoot, taskId);
+      if (!hasProviderOperation(adapter, 'cancel')) {
+        return recordCoreCancelResult(dataRoot, taskId, { kind: 'not_supported' });
+      }
+      const result = await invokeProviderOperation(adapter, 'cancel', {
+        capability: task.capability,
+        remoteTaskId: task.remoteTaskId,
+        signal
+      }, { signal, taskId });
+      return recordCoreCancelResult(dataRoot, taskId, result);
+    });
+  }
+
+  function recover(taskId, adapter) {
+    return runExclusive(taskId, 'recover', async ({ dataRoot, signal }) => {
+      const recovered = recoverCoreTask(dataRoot, taskId);
+      if (recovered.acceptance === 'accepted' && recovered.remoteTaskId
+          && recovered.outcome === 'none'
+          && ['accepted', 'running'].includes(recovered.phase)) {
+        checkAdapterForTask(recovered, adapter);
+        return observeWithinRoot(dataRoot, taskId, adapter, signal);
+      }
+      return recovered;
+    });
+  }
+
+  return Object.freeze({
+    version: PROVIDER_TASK_RUNNER_VERSION,
+    submit,
+    inspect,
+    observe,
+    redeliver,
+    cancel,
+    recover
+  });
+}

package/lib/render.js

@@ -6,8 +6,8 @@
  *   Promise<{ png: Buffer }>
  *
  * BrowserHtmlRenderer：基于宿主 webServer 的 /iris/render/ 静态路由 +
- * dsh-builtin-browser 的 ctx.browser 服务（可选访问，软耦合）。
- * - 不 import dsh-builtin-browser 包，只在运行时探测 ctx.get('browser')
+ * DSH Host Adapter 注入的 browser 端口底层服务（可选访问，软耦合）。
+ * - 不 import dsh-builtin-browser 包，不在通用渲染层探测 DSH ctx
  * - HTML 通过宿主路由以同源 HTTP 打开（避免 file:// 的 CORS 限制）
  * - 每次调用独立临时渲染目录，用后即删
  */
@@ -25,14 +25,42 @@ export class RenderError extends Error {
   }
 }
 
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new RenderError('iris_html_screenshot: 已取消');
+  error.name = 'AbortError';
+  throw error;
+}
+
+function waitForRender(ms, signal) {
+  if (!(ms > 0)) return Promise.resolve();
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', canceled);
+      resolve();
+    };
+    const canceled = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', canceled);
+      const error = new RenderError('iris_html_screenshot: 已取消');
+      error.name = 'AbortError';
+      reject(error);
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener?.('abort', canceled, { once: true });
+  });
+}
+
 /** 渲染临时目录根：$DSH_HOME/iris/v1/render/ */
 export function renderRoot() {
   return path.join(irisHome(), 'render');
 }
 
 /**
- * 基于 ctx.browser（dsh-builtin-browser）的 HTML → PNG 渲染器。
- * @param {{browser?: object, waitMs?: number}} opts browser 为 ctx.get('browser') 服务
+ * 基于 DSH Adapter 持有的原生 browser 服务完成 HTML → PNG。
+ * @param {{browser?: object, waitMs?: number}} opts browser 只在 DSH Adapter 内构造
  */
 export class BrowserHtmlRenderer {
   constructor({ browser, waitMs = 1200 }) {
@@ -40,13 +68,14 @@ export class BrowserHtmlRenderer {
     this.waitMs = waitMs;
   }
 
-  async render({ html, width, height, fullPage }) {
+  async render({ html, width, height, fullPage, signal }) {
     const b = this.browser;
     if (!b || typeof b.open !== 'function' || typeof b.openUrl !== 'function' || typeof b.screenshot !== 'function') {
-      throw new RenderError('iris: 浏览器服务不可用（ctx.get("browser") 为空）——需要启用 dsh-builtin-browser 插件');
+      throw new RenderError('iris: 浏览器服务不可用——需要启用兼容的 dsh-builtin-browser 插件');
     }
     const text = String(html || '').trim();
     if (!text) throw new RenderError('iris_html_screenshot: html 不能为空');
+    throwIfAborted(signal);
 
     // 每次调用独立子目录（随机名），写 index.html
     const dir = path.join(renderRoot(), crypto.randomBytes(6).toString('hex'));
@@ -63,13 +92,15 @@ export class BrowserHtmlRenderer {
     const pngPath = path.join(dir, 'render.png');
 
     try {
-      const session = await b.open();
+      const session = await b.open({ signal });
+      throwIfAborted(signal);
       try {
-        await b.openUrl(session, { url, newTab: true });
-        if (this.waitMs > 0) {
-          await new Promise((r) => setTimeout(r, this.waitMs)); // 等页面加载（无加载完成事件可用的折中）
-        }
-        await b.screenshot(session, { fullPage: fullPage !== false, savePath: pngPath });
+        await b.openUrl(session, { url, newTab: true, signal });
+        throwIfAborted(signal);
+        await waitForRender(this.waitMs, signal); // 等页面加载（无加载完成事件可用的折中）
+        throwIfAborted(signal);
+        await b.screenshot(session, { fullPage: fullPage !== false, savePath: pngPath, signal });
+        throwIfAborted(signal);
       } finally {
         try { await b.close(session); } catch (_) { /* 幂等 */ }
       }

package/lib/tasks.js

@@ -19,6 +19,7 @@ import { parseModelRef } from './models.js';
 import { attentionDisposition, deriveLegacyStatus, deriveUserState, semanticViolations } from './task-semantics.js';
 export { attentionDisposition } from './task-semantics.js';
 import { providerErrorRecord, redactProviderMessage } from './provider-contract.js';
+import { providerPollTaskView } from './provider-adapter.js';
 
 const FILE = () => path.join(irisHome(), 'tasks.json');
 /** 产物目录：$DSH_HOME/iris/v1/outputs */
@@ -454,15 +455,25 @@ export function all() {
   return [...load().tasks].sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)));
 }
 
+/** 终态或已显式处理提醒的 Task v2 可删；活跃/未处理任务仍受保护。 */
+export function taskRecordRemovable(task) {
+  if (!task) return false;
+  if (task.status !== 'running') return true;
+  return isV2Task(task)
+    && ATTENTION_USER_STATES.has(deriveUserState(task))
+    && attentionDisposition(task).status === 'acknowledged';
+}
+
 /**
- * 删除单条任务元数据（仅终态；运行中须先 cancel）。
+ * 删除单条任务元数据。事实终态可直接删除；状态未知只有在用户已读/已重试归档后才可删除。
  * 只删记录，产物文件留在 outputs/（媒体链接因 token 随记录消失而自然失效）。
  * @returns {{ok:boolean, reason?:string}}
  */
 export function remove(id) {
   const t = get(id);
   if (!t) return { ok: false, reason: '任务不存在' };
-  if (t.status === 'running') return { ok: false, reason: '运行中任务请先取消再删除' };
+  if (!taskRecordRemovable(t)) return { ok: false, reason: '活跃或待确认任务请先取消、完成提醒处置，或标为已读后再删除' };
+  stopWatch(id);
   const arr = load().tasks;
   const i = arr.findIndex((x) => x.id === id);
   if (i >= 0) arr.splice(i, 1);
@@ -480,8 +491,10 @@ export function prune(pred) {
   const removed = [];
   const kept = [];
   for (const t of arr) {
-    if (t.status !== 'running' && pred(t)) removed.push(t.id);
-    else kept.push(t);
+    if (taskRecordRemovable(t) && pred(t)) {
+      stopWatch(t.id);
+      removed.push(t.id);
+    } else kept.push(t);
   }
   if (removed.length) {
     load().tasks = kept;
@@ -508,8 +521,8 @@ export function stopWatchAll() {
  * 开始盯守一个异步任务（提交成功后调用）。
  * @param {object} task 已 create 的任务记录（须含 remoteTaskId）
  * @param {object} deps
- *   key(): string                                    —— 每次轮询现取凭据
- *   poll({key, remoteTaskId}): {done,ok,urls,message} —— 协议适配器的查询函数
+ *   key?(): string                                   —— 仅供旧 poll 兼容；v0 Adapter 自持凭据闭包
+ *   poll({key?, remoteTaskId}): Provider poll v0（兼容旧 done/ok 形状）—— 协议适配器查询
  *   onSuccess(task, {urls}): string[]                 —— 结果转存，返回相对 outputs/ 的文件名列表
  *   intervalMs?: number                               —— 轮询间隔（默认 2500）
  *   maxWatchMs?: number                               —— 盯守上限（默认 20 分钟）
@@ -551,7 +564,11 @@ export function watch(task, deps) {
     }
     let r;
     try {
-      r = await deps.poll({ key: deps.key(), remoteTaskId: t.remoteTaskId });
+      const raw = await deps.poll({
+        key: typeof deps.key === 'function' ? deps.key() : undefined,
+        remoteTaskId: t.remoteTaskId
+      });
+      r = providerPollTaskView(raw);
     } catch (err) {
       const n = (errStreak.get(task.id) || 0) + 1;
       errStreak.set(task.id, n);
@@ -571,10 +588,29 @@ export function watch(task, deps) {
     }
     if (!r.ok) {
       const message = redactProviderMessage(r.message || '任务失败');
-      if (!v2) return finishLegacy({ status: 'failed', error: message });
+      if (!v2) {
+        return finishLegacy({ status: r.kind === 'canceled' ? 'canceled' : 'failed', error: message });
+      }
+      if (r.kind === 'unknown') {
+        return finishV2({
+          phase: 'terminal', watchState: 'exhausted', outcome: 'unknown',
+          lastError: r.error || providerErrorRecord(message, {
+            stage: 'poll', category: 'provider', acceptance: 'accepted'
+          }),
+          error: message, finishedAt: new Date().toISOString()
+        });
+      }
+      if (r.kind === 'canceled') {
+        return finishV2({
+          phase: 'terminal', watchState: 'idle', outcome: 'canceled', cancelState: 'remote_confirmed',
+          lastError: r.error, error: message, finishedAt: new Date().toISOString()
+        });
+      }
       return finishV2({
         phase: 'terminal', watchState: 'idle', outcome: 'failed',
-        lastError: providerErrorRecord(message, { stage: 'poll', category: 'provider', acceptance: 'accepted' }),
+        lastError: r.error || providerErrorRecord(message, {
+          stage: 'poll', category: 'provider', acceptance: 'accepted'
+        }),
         error: message, finishedAt: new Date().toISOString()
       });
     }