dsh-data-cleaning-agent 0.8.16 → 0.8.17

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 ## [Unreleased]
 
+## [0.8.17] - 2026-09-08
+
+### Fixed
+- 提示词向导和工作台统一生成 Host 执行凭证；发送已确认范围后不再重复询问额度、源文件路径或写回确认。
+- Host 在高层工具内完成工作流与新 XLSX/异常清单交付，不依赖对话模型编写脚本或页面持续轮询；原始文件不覆盖。
+- 独立清洗会话切换、刷新可恢复业务归属；侧栏入口重开当前工作台，保存任务绑定以访问下载。持久化绑定仅包含会话 ID 与任务 ID。
+- 版本冲突阻止旧说明再次查询，命令重放幂等；候选歧义仍需人工选择，部分失败提供下载并允许显式重试。
+- 修复后台刷新覆盖任务历史导航，并覆盖 DSH root/session 分离实例的事件交接。
+
 ## [0.8.16] - 2026-09-08
 
 ### Changed

package/README.en.md

@@ -8,7 +8,7 @@ Related agents: [数据清洗补全](https://github.com/duhu2000/dsh-data-cleani
 
 > A data cleaning & completion agent plugin for DeepSeek Harness: local CSV/XLSX/JSON engine plus optional Qichacha (QCC) MCP enterprise-data enrichment. Initiated and maintained by the Qichacha (QCC) team.
 >
-> Current source version / 当前源码版本: **0.8.16** (stable release)
+> Current source version / 当前源码版本: **0.8.17** (stable release)
 
 This release unifies spreadsheet previews, column mapping, and enrichment scope across the prompt wizard and workbench. Mapping statuses use color and text; mapped fields automatically enter the scope, with optional extra fields collapsed. Multiple confirmed output columns may share a non-identity field while preserving non-empty values. It fixes saved drafts resetting the scope to five defaults and detects stale Host versions. Preparing a draft does not query QCC; sending starts execution. Fully restart DSH after upgrading. Existing download artifacts are not rewritten.
 

package/README.md

@@ -1,13 +1,13 @@
 # dsh-data-cleaning-agent
 
-本版统一提示词向导与右侧工作台的原表解析、字段映射和补全范围；发布记录见 [发布说明](docs/RELEASE-0.8.16.md)。
+本版统一向导与工作台的 Host 执行闭环：发送后自动生成新 Excel，原文件不修改，工作台入口可恢复；发布记录见 [发布说明](docs/RELEASE-0.8.17.md)。
 
 ## 安装与三分钟上手
 
 数据清洗补全智能体：面向 Excel/CSV/JSON 企业名单，提供数据清洗、表格清洗、清洗补全、去重、企业数据补全与字段补全，支持企查查 MCP 和结果导出。
 
 ```sh
-dsh plugin --profile web add dsh-data-cleaning-agent@0.8.16
+dsh plugin --profile web add dsh-data-cleaning-agent@0.8.17
 ```
 
 请先满足下文的 DSH、连接器及侧边栏依赖要求；安装后完整停止并重启对应 Profile。
@@ -25,7 +25,7 @@ dsh plugin --profile web add dsh-data-cleaning-agent@0.8.16
 
 > 在 DeepSeek Harness 中清洗、补全、画像企业名单数据的智能体插件：本地 CSV/XLSX/JSON 引擎 + 可选企查查（Qichacha/QCC）MCP 企业数据补全，由企查查（Qichacha/QCC）团队发起并维护。
 >
-> 当前源码版本 / Current source version: **0.8.16**（正式版本）
+> 当前源码版本 / Current source version: **0.8.17**（正式版本）
 
 本版上传表格后展示完整清单及空白数量，用绿色、琥珀色、红色及文字区分已通过、待确认和未匹配映射。已映射字段自动纳入补全范围，额外字段默认折叠；多个原列可经确认使用同一非主体字段，分别补空并保留非空原值。修复 Host 草稿重置为默认五字段的问题，增加前后端版本错配提示。生成说明不查询，发送才执行；升级后需完整重启 DSH，历史下载文件不自动改写。
 

package/docs/RELEASE-0.8.17.md

@@ -0,0 +1,26 @@
+# dsh-data-cleaning-agent v0.8.17
+
+## 本版改进
+
+发送在向导或右侧工作台确认的任务说明后，由同一个 Host 高层工具负责匹配、补全、生成新的 XLSX 与异常清单，并将下载绑定到任务。无需再次确认额度或提供源文件路径；不覆盖上传的原始文件，不由模型运行 Bash 拼装替代报表。
+
+- 保留已确认原列、多列共用补全字段、仅补空白及非空 0/false 保护。
+- 真正的多候选在工作台确认；授权、限流等异常不自动重试或扩大范围。
+- 过期任务 revision 在查询前阻断；同一命令重放不重复扣量。
+- 刷新与切换后恢复独立清洗会话；侧栏重新打开当前工作台。Host 生成文件不依赖页面存在，已保存结果可跨 Host 重启下载。
+- 只在浏览器保存会话 ID → 任务 ID 绑定，不持久化原始名单。执行中的 Host 进程不可强制重启；尚未生成的命令、候选与运行明细仍可能过期，不能自动重新查询。
+- 未选外部字段时不发起 QCC 调用，可使用工作台本地清洗与导出。
+
+## 验证
+
+241 项自动化测试、10 组浏览器回归通过。使用合成数据和隔离的 ToolRuntime/Chromium，不调用真实企查查账号、不修改客户测试文件。覆盖真实 XLSX 内容回读、双列补空、原值保护、重放幂等、候选续跑、部分失败重试、磁盘写入失败及恢复下载。浏览器覆盖浅色/深色与五种视口，分离 root/session 实例验证向导凭证交接。
+
+## 升级
+
+保存未完成任务后安装：
+
+`dsh plugin --profile web add dsh-data-cleaning-agent@0.8.17`
+
+完整重启对应 DSH Profile 并刷新页面；仅刷新浏览器不会更新 Host。旧对话中的普通提示词不会自动改成新凭证，请在升级后的工作台重新生成。历史导出不会被改写。本次发布不自动重启或安装到本机正在运行的 DSH。
+
+回滚可安装 0.8.16，但会失去本版 Host 自动交付与会话恢复逻辑。共享字段内核、AI 填表版本均不变。

package/lib/client.js

@@ -1231,10 +1231,27 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
     ];
     const CLEANING_SESSION_EVENT = 'dsh:data-cleaning-session-ownership';
     let activeCleaningSessionId = null;
+    const TASK_BINDINGS_KEY = 'dsh.data-cleaning-agent.task-bindings.v1';
+    const ownedSessionId = (id) => /^session-dsh-data-cleaning-agent-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(String(id || ''));
+    function readTaskBindings() {
+      try {
+        const value = JSON.parse(window.localStorage?.getItem(TASK_BINDINGS_KEY) || '{}');
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+      } catch { return {}; }
+    }
+    function bindTask(sessionId, taskId) {
+      if (!ownedSessionId(sessionId)) return;
+      try {
+        const bindings = readTaskBindings();
+        delete bindings[sessionId];
+        bindings[sessionId] = taskId;
+        window.localStorage?.setItem(TASK_BINDINGS_KEY, JSON.stringify(Object.fromEntries(Object.entries(bindings).slice(-200))));
+      } catch {}
+    }
 
     try {
       // 旧版本持久化过 sessionId；但 DSH 会复用空白新会话，无法仅凭 ID 判断入口来源。
-      // 子系统归属因此只在当前页面、经菜单显式激活，并在升级时清除所有旧标记。
+      // 清除旧的无前缀归属标记；新的独立会话前缀可安全恢复，不认领其它智能体会话。
       for (const key of CLEANING_SESSION_STORAGE_KEYS) window.sessionStorage?.removeItem(key);
     } catch (_error) {
       // sessionStorage 可能被禁用；内存态不受影响。
@@ -1331,10 +1348,12 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       };
       const leaveSubsystem = () => {
         const sessionId = activeCleaningSessionId;
-        if (sessionId) clearCleaningDraft(ctx, sessionId, true);
+        if (sessionId && !ownedSessionId(sessionId)) clearCleaningDraft(ctx, sessionId, true);
         deactivateCleaningSession(sessionId);
       };
-      // 升级 / 刷新后不恢复子系统所有权；仅清理由旧版本遗留且仍未被用户编辑的默认文案。
+      // Only our independently-created native session namespace may regain ownership.
+      const initialSession = ctx.sessions?.list?.getSnapshot?.()?.current;
+      if (ownedSessionId(initialSession)) markCleaningSession(initialSession);
       clearStaleDefaultDraft();
       // DSH 会在插件 apply() 之后异步恢复 composer draft。在首屏稳定期内
       // 监听 DOM 变化并仅清理完全匹配本插件默认文案，或同时命中
@@ -1359,6 +1378,9 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         const nextSessionId = selected.current;
         if (activeCleaningSessionId && nextSessionId !== activeCleaningSessionId) {
           leaveSubsystem();
+        }
+        if (!activeCleaningSessionId && ownedSessionId(nextSessionId)) {
+          markCleaningSession(nextSessionId);
         } else if (!activeCleaningSessionId) {
           clearStaleDefaultDraft();
         }
@@ -1408,14 +1430,15 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       lines.push(`需要补全的字段 / 维度：${enrichLabels.length ? enrichLabels.join('、') : '不调用外部补全，仅输出本地清洗结果'}。`);
       if (mode === 'excel' && config.headers?.length) {
         const pairs = config.mappings || [];
-        lines.push(`原表共 ${config.headers.length} 列。确认写回：${pairs.map((item) => `「${item.sourceField}」←${resultFieldLabel(item.targetField)}`).join('；') || '暂无'}。`);
+        lines.push(`原表共 ${config.headers.length} 列。新文件原列补空映射：${pairs.map((item) => `「${item.sourceField}」←${resultFieldLabel(item.targetField)}`).join('；') || '暂无'}。`);
         const skipped = config.headers.filter((header) => !pairs.some((item) => item.sourceField === header));
         if (skipped.length) lines.push(`暂不补全的原列：${skipped.join('、')}；保留原值，不猜测或用相近指标替代。`);
         const added = (config.enrichmentKeys || []).filter((id) => !pairs.some((item) => item.targetField === id));
         lines.push(`仅补已确认原列的空白单元格，保留非空值（含 0）。多个原列可共用一个补全字段，查询按主体与工具去重。额外新增字段：${added.map(resultFieldLabel).join('、') || '无'}。`);
       }
       lines.push(`处理规则：优先使用${anchorLabels.length ? anchorLabels.join('、') : '企业名称、统一社会信用代码或注册号'}精确匹配；${config.matchRules?.manualReviewAmbiguous === false ? '精确匹配失败时直接输出未匹配记录' : '精确匹配失败时再进入模糊候选，存在多个候选必须暂停并让我确认，不得默认选择第一项'}。`);
-      lines.push('请先生成数据质量体检与匹配摘要，经我确认后再执行需要消耗额度的企查查 MCP 调用；企查查连接、套餐额度和费用均由当前用户自己的账号承担。缺失或无权限字段请留空并标记原因，不得编造。');
+      lines.push('发送即确认执行工作台已配置的范围，不再重复确认额度或写回。企查查连接、套餐额度和费用均由当前用户自己的账号承担。缺失或无权限字段请留空并标记原因，不得编造。');
+      lines.push('交付方式：Host 自动生成新的清洗补全结果 XLSX，在工作台下载。不得修改上传源文件，不索要本地路径，不使用 Bash 或另行编写导出脚本。');
       lines.push('完成后保留来源原值、标准主体、匹配状态与字段来源，并提供结果和待复核清单的导出。');
       return lines.join('\n\n');
     }
@@ -1662,6 +1685,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
     function cacheWorkflowTask(actions, sessionId, task) {
       if (!task) return null;
       if (sessionId) workflowTaskBySession.set(String(sessionId), task);
+      bindTask(sessionId, task.id);
       actions.setWorkflowTask(task);
       if (task.title) actions.setTaskTitle(task.title);
       if (Array.isArray(task.objectives)) actions.setObjectives(task.objectives);
@@ -1692,10 +1716,17 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       return cacheWorkflowTask(actions, sessionId, response.task);
     }
 
-    async function ensureWorkflowTask(actions, sessionId, draft = {}) {
+    async function ensureWorkflowTask(actions, sessionId, draft = {}, restoreStage = true) {
       const key = String(sessionId || 'unassigned');
       const cached = workflowTaskBySession.get(key);
       if (cached) return cacheWorkflowTask(actions, sessionId, cached);
+      const saved = readTaskBindings()[key];
+      if (ownedSessionId(key) && /^dcw-[a-zA-Z0-9-]+$/.test(saved || '')) {
+        const response = await requestJson(`/data-cleaning/api/workflow/tasks/${encodeURIComponent(saved)}`);
+        const task = cacheWorkflowTask(actions, sessionId, response.task);
+        if (restoreStage) actions.setStep(task.stage || 'upload');
+        return task;
+      }
       return createWorkflowTask(actions, sessionId, draft);
     }
 
@@ -1748,6 +1779,69 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       return cacheWorkflowTask(actions, sessionId, response.task);
     }
 
+    async function stageConfirmedWorkflow(actions, sessionId, expected = null) {
+      const host = await requestJson('/data-cleaning/api/g5/capabilities');
+      if (host?.workflowExecutionVersion !== 1) throw new Error('页面与 Host 版本不一致。请保存任务后升级并完整重启 DSH；当前 Host 不支持自动生成结果文件。');
+      let task = await ensureWorkflowTask(actions, sessionId);
+      if (expected) {
+        const sameSet = (a, b) => JSON.stringify([...(a || [])].sort()) === JSON.stringify([...(b || [])].sort());
+        if (!sameSet(task.fieldSelection, expected.enrichmentKeys)
+          || (expected.mode === 'excel' && (task.source?.fileName !== expected.fileName
+            || task.source?.rowCount !== expected.entryCount
+            || JSON.stringify(task.mappings) !== JSON.stringify(expected.mappings)))) {
+          throw new Error('工作台保存的范围与向导不一致，请重试确认；未生成执行凭证。');
+        }
+      }
+      const runtime = runtimeFor(task.id, false);
+      if (!task.fieldSelection?.length) throw new Error('当前未选择企查查补全字段。请在规则页选择补全字段，或使用工作台本地清洗与结果导出；不会发起企查查调用。');
+      if (!runtime?.rows?.length) throw new Error('Host 名单尚未载入，请先解析数据。');
+      if (task.state === 'uploaded') task = await workflowAction(actions, sessionId, task, 'rules', {
+        objectives: task.objectives, fieldSelection: task.fieldSelection, mappings: task.mappings, matchRules: task.matchRules,
+      });
+      if (task.state === 'rules_confirmed') task = await workflowAction(actions, sessionId, task, 'quality', {
+        summary: qualitySummaryFor(runtime.rows, task.mappings),
+      });
+      const response = await requestJson('/data-cleaning/api/g5/commands', 'POST', {
+        kind: 'enrich', workflowOwned: true, expectedRevision: task.revision, taskId: task.id,
+        rows: runtime.rows, headers: runtime.headers, fieldSelection: task.fieldSelection,
+      });
+      if (!response.command?.commandId || !response.command?.prompt) throw new Error('Host 未返回执行凭证；未发送任务。');
+      return response.command;
+    }
+
+    async function refreshHostedTask(actions, sessionId, taskId, run, navigate = true) {
+      const response = await requestJson(`/data-cleaning/api/workflow/tasks/${encodeURIComponent(taskId)}`);
+      const selectedTask = workflowTaskBySession.get(String(sessionId));
+      if (selectedTask && selectedTask.id !== taskId) return response.task;
+      if (selectedTask && selectedTask.revision > response.task.revision) return selectedTask;
+      workflowTaskBySession.set(String(sessionId), response.task);
+      bindTask(sessionId, taskId);
+      if (isCleaningSession(sessionId)) {
+        if (!run && response.task.qccRunId && ['review_required', 'partial'].includes(response.task.state)) {
+          try { run = await requestJson(`/data-cleaning/api/g5/run/${encodeURIComponent(response.task.qccRunId)}`); }
+          catch { actions.setError('Host 中的候选或重试数据已失效。已有结果仍可下载；重新查询需新建任务，不会自动重复扣量。'); }
+        }
+        if (!isCleaningSession(sessionId) || workflowTaskBySession.get(String(sessionId))?.id !== taskId) return response.task;
+        cacheWorkflowTask(actions, sessionId, response.task);
+        if (run) {
+          actions.setQccRun(run);
+          const runtime = runtimeFor(taskId);
+          runtime.resultRows.qcc = run.rows;
+          if (!runtime.rows.length) { runtime.rows = run.rows; runtime.headers = response.task.source?.headers || run.headers || []; }
+        }
+        if (navigate) actions.setStep(response.task.stage || 'upload');
+      }
+      return response.task;
+    }
+    function watchHostedCommand(actions, sessionId, command) {
+      void waitForQccCommand(command.commandId, 1800).then(async (completed) => {
+        await refreshHostedTask(actions, sessionId, command.taskId, completed.run);
+        if (completed.state === 'failed') throw new Error(completed.error?.message || 'Host 执行失败，请在工作台查看状态。');
+      }).catch((error) => {
+        if (isCleaningSession(sessionId)) actions.setError(error.message || String(error));
+      });
+    }
+
     /** 工作台 store：入口按钮与工作台共享 open，并保存当前 taskId 的可持久化 UI 元数据。 */
     function createWorkbenchStore() {
       return defineStore({
@@ -1944,6 +2038,11 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
     async function startCleaningSession(ctx) {
       const workspace = ctx.workspaces.list.getSnapshot();
       const current = ctx.sessions.list.getSnapshot().current;
+      if (ownedSessionId(current)) {
+        markCleaningSession(current);
+        requestWorkbenchOpen(workflowTaskBySession.get(String(current))?.stage || 'upload', current);
+        return current;
+      }
       const items = Array.isArray(workspace.items) ? workspace.items : [];
       const currentWorkspace = current === undefined
         ? undefined
@@ -2040,6 +2139,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
     const WORKBENCH_OPEN_EVENT = 'dsh:data-cleaning-workbench-open';
     const WORKBENCH_DATASET_EVENT = 'dsh:data-cleaning-workbench-dataset';
     const WORKBENCH_DRAFT_EVENT = 'dsh:data-cleaning-workbench-draft';
+    const WORKBENCH_PREPARE_EVENT = 'dsh:data-cleaning-workbench-prepare';
 
     // session scope 不能复用 root scope 的 store handle。DSH 当前会分别物化 root/session
     // 插槽组件，因此以 document 事件跨 scope 通知；闭包引用仅作为无 DOM 测试降级。
@@ -2057,6 +2157,14 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       if (rootWorkbenchActions) openWorkbench(rootWorkbenchActions, step, sessionId);
     }
 
+    function requestPreparedWorkflow(sessionId, config) {
+      return new Promise((resolve, reject) => {
+        const event = document.createEvent('CustomEvent');
+        event.initCustomEvent(WORKBENCH_PREPARE_EVENT, false, true, { sessionId, config, resolve, reject });
+        if (document.dispatchEvent(event)) reject(new Error('工作台尚未就绪，请稍后重试。'));
+      });
+    }
+
     /** 把提示词生成器解析出的完整表格交给 root 工作台，不把整表塞进模型上下文。 */
     function requestWorkbenchDataset(result, sessionId, source) {
       if (typeof document !== 'undefined'
@@ -2667,7 +2775,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         imageCommandId: imageCommand?.commandId ?? '',
         imageState: imageCommand?.state ?? null,
       });
-      const generatePrompt = () => {
+      const generatePrompt = async () => {
         const sourceError = validateSource();
         if (sourceError) { setError(sourceError); return; }
         if (!anchorKeys.length) { setError('请至少选择一个企业主体匹配主键。'); return; }
@@ -2687,17 +2795,10 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           removeImage(sessionId, imageAttachment);
           setImageAttachment(null);
         }
-        const prompt = buildTaskPrompt(config);
-        try {
-          inputActions.setDraft(prompt);
-          const updatedInput = getInputSnapshot?.(sessionId);
-          if (updatedInput && updatedInput.draft !== prompt) throw new Error('当前对话尚未接收任务说明，请稍后重试回填。');
-        } catch (draftError) {
-          setError(draftError instanceof Error ? draftError.message : String(draftError));
-          return;
-        }
         if (mode === 'text') {
           requestWorkbenchDataset(entriesToDataset(config.entries), sessionId, { type: 'text', fileName: '' });
+        } else if (mode === 'excel' && spreadsheetData) {
+          requestWorkbenchDataset(spreadsheetData, sessionId, { type: spreadsheetData.fmt || 'xlsx', fileName: spreadsheetFileName });
         }
         requestWorkbenchDraft({
           title: `企业数据清洗补全任务 · ${config.entryCount || '待解析'} 条`,
@@ -2707,6 +2808,20 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           ...(mode === 'excel' ? { mappings: spreadsheetMappings } : {}),
           source: { type: mode === 'excel' ? 'xlsx' : mode, fileName: config.fileName || '', rowCount: config.entryCount || 0 },
         }, sessionId);
+        setBusy(true);
+        try {
+          let prompt = buildTaskPrompt(config);
+          if (mode !== 'image' || imageCommand?.state === 'completed') {
+            const command = await requestPreparedWorkflow(sessionId, config);
+            prompt = command.prompt + '\n\n' + buildTaskPrompt(config);
+          }
+          inputActions.setDraft(prompt);
+          const updatedInput = getInputSnapshot?.(sessionId);
+          if (updatedInput && updatedInput.draft !== prompt) throw new Error('当前对话尚未接收任务说明，请稍后重试回填。');
+        } catch (draftError) {
+          setError(draftError instanceof Error ? draftError.message : String(draftError));
+          return;
+        } finally { setBusy(false); }
         setError(null);
         setOpen(false);
         setTimeout(() => {
@@ -3355,6 +3470,14 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
             });
           }
         };
+        const handlePrepare = (event) => {
+          event.preventDefault();
+          const { sessionId, config, resolve, reject } = event.detail;
+          queueWorkflowOperation(sessionId, () => stageConfirmedWorkflow(actions, sessionId, config)).then((command) => {
+            watchHostedCommand(actions, sessionId, command);
+            resolve(command);
+          }, reject);
+        };
         const handleDraft = (event) => {
           event?.preventDefault?.();
           const detail = event?.detail ?? {};
@@ -3374,12 +3497,14 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           document.addEventListener(WORKBENCH_OPEN_EVENT, handleOpen);
           document.addEventListener(WORKBENCH_DATASET_EVENT, handleDataset);
           document.addEventListener(WORKBENCH_DRAFT_EVENT, handleDraft);
+          document.addEventListener(WORKBENCH_PREPARE_EVENT, handlePrepare);
         }
         return () => {
           if (typeof document !== 'undefined' && typeof document.removeEventListener === 'function') {
             document.removeEventListener(WORKBENCH_OPEN_EVENT, handleOpen);
             document.removeEventListener(WORKBENCH_DATASET_EVENT, handleDataset);
             document.removeEventListener(WORKBENCH_DRAFT_EVENT, handleDraft);
+            document.removeEventListener(WORKBENCH_PREPARE_EVENT, handlePrepare);
           }
           stopJobsPolling();
           if (rootWorkbenchActions === actions) rootWorkbenchActions = null;
@@ -3393,14 +3518,34 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           if (!disposed) actions.setWorkflowContract(response.contract);
         }).catch(() => {});
         loadWorkflowTasks(actions);
-        if (activeSessionId && !workflowTaskBySession.has(String(activeSessionId))) {
-          queueWorkflowOperation(activeSessionId, () => ensureWorkflowTask(actions, activeSessionId)).catch((taskError) => {
+        if (activeSessionId) {
+          queueWorkflowOperation(activeSessionId, async () => {
+            const task = await ensureWorkflowTask(actions, activeSessionId, {}, step !== 'history');
+            await refreshHostedTask(actions, activeSessionId, task.id, null, false);
+          }).catch((taskError) => {
             if (!disposed) actions.setError(taskError instanceof Error ? taskError.message : String(taskError));
           });
         }
         return () => { disposed = true; };
       }, [open, activeSessionId, actions]);
 
+      // Reopening during execution follows Host metadata, even when the original
+      // command watcher was lost on page reload. This performs no QCC calls.
+      react.useEffect(() => {
+        if (!open || !workflowTask?.id || !['matching', 'enriching'].includes(workflowTask.state)) return undefined;
+        let disposed = false, timer;
+        const poll = async () => {
+          try {
+            const task = await refreshHostedTask(actions, activeSessionId, workflowTask.id, null, false);
+            if (disposed) return;
+            if (['matching', 'enriching'].includes(task.state)) timer = setTimeout(poll, 2000);
+            else if (step === 'match' || step === 'enrich') actions.setStep(task.stage || step);
+          } catch (error) { if (!disposed) actions.setError(error.message); }
+        };
+        timer = setTimeout(poll, 2000);
+        return () => { disposed = true; clearTimeout(timer); };
+      }, [open, workflowTask?.id, workflowTask?.state, activeSessionId, step, actions]);
+
       // 非模态右栏会覆盖 Host 的中央画布；按实际重叠量把 composer 能力栏左移，
       // 保证 Mockup 中的五个入口在窄桌面视口仍可见、可点击。展开态专注工作台，
       // 不强行挤压到不足一栏的剩余区域。
@@ -3624,6 +3769,10 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         const reviewRequired = Number(summary.ambiguous ?? run.reviewQueue?.length ?? 0);
         const currentTask = workflowTaskBySession.get(String(activeSessionId || 'unassigned')) ?? cachedTask;
         let current = currentTask;
+        if (currentTask?.qccRunId === run.runId && ['completed', 'partial', 'review_required', 'export_ready'].includes(currentTask.state)) {
+          actions.setStep(currentTask.stage || 'download');
+          return currentTask;
+        }
         // partial 表示上一轮仍有失败项。重试成功后可直接重进 enrichment，
         // 无需伪造一次新的 match 转换；若重试产生候选，再回到人工核验。
         if (currentTask?.state !== 'partial' || reviewRequired > 0) {
@@ -3664,14 +3813,16 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         if (!activeSessionId || typeof sendSessionCommand !== 'function') {
           throw new Error('当前会话无法提交数据清洗补全企查查任务');
         }
+        const latest = workflowTaskBySession.get(String(activeSessionId)) ?? cachedTask;
         const prepared = await api('/data-cleaning/api/g5/commands', {
-          ...payload,
+          ...payload, workflowOwned: true, expectedRevision: latest.revision,
           ...(payload.kind === 'enrich' ? {} : { confirmPaidCalls: true }),
         });
         const command = prepared?.command;
         if (!command?.commandId || !command?.prompt) throw new Error('Host 未返回有效的企查查任务命令');
         await sendSessionCommand(activeSessionId, command.prompt);
         const completedCommand = await waitForQccCommand(command.commandId);
+        await refreshHostedTask(actions, activeSessionId, command.taskId, completedCommand.run);
         if (completedCommand.state === 'failed') {
           const commandError = new Error(completedCommand.error?.message || '智能体企查查任务执行失败');
           commandError.code = completedCommand.error?.code;
@@ -3681,40 +3832,14 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         return completedCommand.run;
       };
 
-      const prepareEditableQccCommand = async (payload) => {
+      const prepareEditableQccCommand = async () => {
         if (!activeSessionId || typeof setSessionDraft !== 'function') {
           throw new Error('当前会话无法回填可编辑的数据清洗补全任务说明');
         }
-        const host = await api('/data-cleaning/api/g5/capabilities');
-        if (host?.draftPreparationVersion !== 2 || host?.multipleOutputColumns !== true) {
-          throw new Error('页面与 Host 版本不一致。请先保存或导出现有任务，再升级并重启 DSH、刷新页面。生成任务说明不需要勾选费用确认。');
-        }
-        const prepared = await api('/data-cleaning/api/g5/commands', {
-          ...payload,
-        });
-        const command = prepared?.command;
-        if (!command?.commandId || !command?.prompt) throw new Error('Host 未返回有效的企查查任务命令');
-        actions.setQccCapabilities({ capabilities: { ready: true } });
+        const command = await queueWorkflowOperation(activeSessionId, () => stageConfirmedWorkflow(actions, activeSessionId));
         setSessionDraft(activeSessionId, command.prompt);
         actions.close();
-
-        // 发送权仍在用户手中：草稿回填不会调用 QCC。用户发送后，
-        // Agent-owned 工具改变 command 状态；本地安全轮询只读取结果并回写工作流。
-        void waitForQccCommand(command.commandId, 1800).then(async (completedCommand) => {
-          if (completedCommand.state === 'failed') {
-            const commandError = new Error(completedCommand.error?.message || '智能体企查查任务执行失败');
-            commandError.code = completedCommand.error?.code;
-            throw commandError;
-          }
-          if (!completedCommand.run) throw new Error('智能体企查查任务完成但结果已失效');
-          await queueWorkflowOperation(activeSessionId, () => applyQccRun(completedCommand.run));
-        }).catch(async (commandError) => {
-          if (['QCC_NOT_CONNECTED', 'QCC_TOOL_UNAVAILABLE', 'QCC_AUTH_REQUIRED'].includes(commandError?.code)) {
-            const latest = workflowTaskBySession.get(String(activeSessionId || 'unassigned')) ?? cachedTask;
-            try { await workflowAction(actions, activeSessionId, latest, 'authorization-required'); } catch (_workflowError) {}
-          }
-          actions.setError(commandError instanceof Error ? commandError.message : String(commandError));
-        });
+        watchHostedCommand(actions, activeSessionId, command);
         return command;
       };
 
@@ -3842,7 +3967,17 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         }
       };
 
-      const resumeWorkflowTask = (task) => {
+      const resumeWorkflowTask = async (task) => {
+        try {
+          workflowTaskBySession.set(String(activeSessionId), task);
+          task = await refreshHostedTask(actions, activeSessionId, task.id);
+          if (task.qccRunId) {
+            try {
+              const response = await api(`/data-cleaning/api/g5/run/${encodeURIComponent(task.qccRunId)}`);
+              actions.setQccRun(response);
+            } catch { /* Expired run data does not prevent persisted artifact downloads. */ }
+          }
+        } catch (error) { actions.setError(error.message); return; }
         workflowTaskBySession.set(String(activeSessionId || 'unassigned'), task);
         actions.setWorkflowTask(task);
         actions.setTaskTitle(task.title);

package/lib/qcc-command.js

@@ -7,6 +7,7 @@
  * and lets this high-level tool perform the paid calls with exec.token.
  */
 import { randomUUID } from 'node:crypto';
+import { WorkflowError } from './workflow.js';
 import { QccBridgeError } from './qcc.js';
 import { fieldLabel, normalizeFieldSelection } from './workflow-contract.js';
 
@@ -21,6 +22,7 @@ function clone(value) {
 
 function safeError(error) {
   if (error instanceof QccBridgeError) return error.toJSON();
+  if (error instanceof WorkflowError) return { code: error.code, message: error.message, retryable: false };
   return new QccBridgeError('QCC_COMMAND_FAILED', 'Data-cleaning QCC command failed', {
     retryable: false,
   }).toJSON();
@@ -45,6 +47,8 @@ function normalizedInput(input = {}) {
     return {
       kind,
       taskId,
+      workflowOwned: input.workflowOwned === true,
+      workflowRevision: input.workflowRevision,
       rows: clone(rows),
       headers: Array.isArray(input.headers) ? input.headers.map(String) : [],
       nameField: String(input.nameField ?? 'name'),
@@ -59,6 +63,8 @@ function normalizedInput(input = {}) {
       kind,
       taskId,
       runId,
+      workflowOwned: input.workflowOwned === true,
+      workflowRevision: input.workflowRevision,
       companyName: requiredText(input.companyName, 'QCC_REVIEW_NOT_PENDING', 'A company name is required'),
       selectedCreditNo: requiredText(input.selectedCreditNo, 'QCC_CANDIDATE_INVALID', 'A selected credit number is required'),
     };
@@ -66,7 +72,7 @@ function normalizedInput(input = {}) {
   const companyNames = [...new Set((Array.isArray(input.companyNames) ? input.companyNames : [])
     .map((name) => String(name).trim()).filter(Boolean))];
   if (companyNames.length === 0) throw new QccBridgeError('QCC_RETRY_EMPTY', 'At least one failed company must be selected');
-  return { kind, taskId, runId, companyNames };
+  return { kind, taskId, runId, companyNames, workflowOwned: input.workflowOwned === true, workflowRevision: input.workflowRevision };
 }
 
 export function serializeQccCommandPrompt(command) {
@@ -99,11 +105,15 @@ export function serializeQccCommandPrompt(command) {
     '',
     `发送本说明后，请仅调用一次数据清洗补全执行工具（${TOOL_QCC_COMMAND}），参数只传递上述安全任务凭证。`,
     '不要要求重复粘贴企业名单，不要直接调用 mcp__qcc-* 工具，不要重试、扩大名单或追加字段。',
+    input.workflowOwned
+      ? '发送即执行已确认方案，不再询问额度或写回确认。Host 会自动生成新的清洗补全结果 XLSX，原始上传文件不修改。不要寻找源文件路径、运行 Bash、编写导出脚本或另行覆盖源文件。'
+      : '这是兼容模式命令，返回工作台查看结果并导出。不要另行寻找或覆盖源文件；如需自动交付新 Excel，请在最新版工作台重新生成任务说明。',
+    '高层工具返回后只汇报真实状态，并提示返回数据清洗补全工作台下载；主体多候选或真实授权异常才需要人工处理。',
   ].join('\n');
 }
 
 export class QccCommandStore {
-  constructor({ bridge, runs, clock = () => Date.now(), ttlMs = DEFAULT_TTL_MS, maxCommands = DEFAULT_MAX_COMMANDS } = {}) {
+  constructor({ bridge, runs, clock = () => Date.now(), ttlMs = DEFAULT_TTL_MS, maxCommands = DEFAULT_MAX_COMMANDS, lifecycle } = {}) {
     if (!bridge || !runs) throw new TypeError('QccCommandStore requires bridge and runs');
     this.bridge = bridge;
     this.runs = runs;
@@ -111,6 +121,7 @@ export class QccCommandStore {
     this.ttlMs = ttlMs;
     this.maxCommands = maxCommands;
     this.commands = new Map();
+    this.lifecycle = lifecycle;
   }
 
   cleanup(reserveSlot = false) {
@@ -171,6 +182,8 @@ export class QccCommandStore {
       runId: record.runId,
       error: record.error,
       estimate: record.estimate,
+      workflowOwned: record.input.workflowOwned === true,
+      delivery: record.delivery ?? null,
       expiresInMs: this.ttlMs,
     });
   }
@@ -190,15 +203,18 @@ export class QccCommandStore {
     if (record.promise) return record.promise;
     record.state = 'running';
     record.updatedAt = new Date(this.clock()).toISOString();
-    record.promise = this.execute(record, execution)
-      .then((run) => {
+    record.promise = Promise.resolve().then(() => this.lifecycle?.beforeRun(record))
+      .then(() => this.execute(record, execution))
+      .then(async (run) => {
         record.runId = run.runId;
+        record.delivery = await this.lifecycle?.complete(record, run);
         record.state = 'completed';
         record.updatedAt = new Date(this.clock()).toISOString();
         record.touchedAtMs = this.clock();
         return this.toolResult(record, run);
       })
-      .catch((error) => {
+      .catch(async (error) => {
+        try { await this.lifecycle?.failed(record, error); } catch { /* Preserve the original execution failure. */ }
         record.error = safeError(error);
         record.state = 'failed';
         record.updatedAt = new Date(this.clock()).toISOString();
@@ -244,6 +260,7 @@ export class QccCommandStore {
       runId: run.runId,
       state: run.state,
       summary: run.summary,
+      ...(record.delivery ? { deliveryState: record.delivery.state, artifactCount: record.delivery.artifacts.length } : {}),
     });
   }
 }
@@ -267,6 +284,8 @@ export function registerQccCommandTool(tools, commands) {
           taskId: { type: 'string' },
           runId: { type: 'string' },
           state: { type: 'string' },
+          deliveryState: { type: 'string' },
+          artifactCount: { type: 'integer' },
           summary: {
             type: 'object',
             additionalProperties: false,
@@ -288,7 +307,7 @@ export function registerQccCommandTool(tools, commands) {
       },
       render: (_args, value) => [{
         type: 'text',
-        text: `数据清洗补全企查查任务已完成：${value.summary?.enriched ?? 0}/${value.summary?.totalRows ?? 0} 条已补全，状态 ${value.state}。`,
+        text: `数据清洗补全：${value.summary?.enriched ?? 0}/${value.summary?.totalRows ?? 0} 条已补全。${value.artifactCount ? 'Host 已生成新的结果 XLSX，请返回工作台「结果下载」。源文件未修改，无需再次确认或提供路径。' : value.deliveryState === 'review_required' ? '存在多候选，请返回工作台确认主体。' : '请返回工作台查看任务状态。'}`,
       }],
     },
     async execute(args, exec) {

package/lib/skill-enrich.js

@@ -56,7 +56,9 @@ export function registerEnrichSkill(skills) {
       '',
       'Workbench execution request (highest priority):',
       '- If the visible user message is the readable data-cleaning task summary generated by the workbench, contains a `安全任务凭证` beginning with `dcq-`, and explicitly requests `data_cleaning_qcc_run`, treat that credential as `commandId`, call the high-level tool exactly once with only `commandId`, then stop.',
-      '- The Host already holds the rows, billing confirmation and field selection. Do not ask the user to paste rows, do not call any `mcp__qcc-*` tool directly, do not retry, and do not expand the batch.',
+      '- The Host already holds the rows, billing confirmation and field selection. Sending the visible staged scope is the execution confirmation: do not ask again about quota or writing a file. Do not ask the user to paste rows, do not call any `mcp__qcc-*` tool directly, do not retry, and do not expand the batch.',
+      '- The Host automatically creates a NEW enriched Excel and attaches downloads to this workflow task. Never use Bash, search the filesystem, request the original path, overwrite the source workbook, or create substitute CSV reports for a workbench task. Report delivery only from the high-level tool result; unresolved entity candidates are confirmed in the workbench.',
+      '- If a message says the workbench holds its source but has no valid dcq- credential, return to the workbench to regenerate the task description. Do not fall back to free-form MCP or filesystem execution.',
       '',
       'Workflow:',
       '1. Check QCC availability first: run `qcc_oauth_status`. If not connected, tell the user to run `qcc_oauth_connect` first and stop. If the token is expired, guide the user to `qcc_oauth_connect` (it reuses the grant and refreshes without a new authorization page).',

package/lib/web.js

@@ -16,6 +16,7 @@ import { PHASE3_BATCH_LIMITS, Phase3BatchService, Phase3RunStore } from './qcc-p
 import { publicWorkflowContract } from './workflow-contract.js';
 import { DataCleaningWorkflowStore, WorkflowError } from './workflow.js';
 import { ArtifactError, WorkflowArtifactStore } from './artifacts.js';
+import { createWorkflowExecution } from './workflow-execution.js';
 import {
   ImageIntakeError,
   ImageIntakeStore,
@@ -305,7 +306,8 @@ export function mountWebRoutes(wctx, { logger, report, TOOL_NAME, SKILL_NAME })
   const qccBridge = new QccHostBridge({ tools, logger });
   const imageIntake = new ImageIntakeStore({ tools });
   const g5Runs = new G5RunStore();
-  const qccCommands = new QccCommandStore({ bridge: qccBridge, runs: g5Runs });
+  const execution = createWorkflowExecution({ getWorkflow: () => getWorkflow(), artifacts: wctx.fs ? new WorkflowArtifactStore({ fs: wctx.fs }) : null });
+  const qccCommands = new QccCommandStore({ bridge: qccBridge, runs: g5Runs, lifecycle: execution });
   if (typeof tools?.register === 'function') {
     disposers.push(registerQccCommandTool(tools, qccCommands));
     disposers.push(registerImageIntakeTool(tools, imageIntake));
@@ -620,6 +622,7 @@ export function mountWebRoutes(wctx, { logger, report, TOOL_NAME, SKILL_NAME })
       draftPreparationVersion: 2,
       draftPaidCallConfirmationRequired: false,
       multipleOutputColumns: true,
+      workflowExecutionVersion: 1,
       idempotencyRequired: true,
       candidateResume: true,
       manualRetry: true,
@@ -650,7 +653,7 @@ export function mountWebRoutes(wctx, { logger, report, TOOL_NAME, SKILL_NAME })
           ok: true,
           marker: 'g5-agent-command',
           paidCalls: false,
-          command: qccCommands.prepare(payload),
+          command: qccCommands.prepare(payload.workflowOwned ? await execution.prepare(payload) : payload),
         });
       }
       if (rest.length === 1 && req.method === 'GET') {
@@ -665,6 +668,7 @@ export function mountWebRoutes(wctx, { logger, report, TOOL_NAME, SKILL_NAME })
       if (error instanceof SyntaxError) {
         return writeJson(res, 400, { ok: false, code: 'DC_BAD_JSON', message: 'Request body must be valid JSON.' });
       }
+      if (error instanceof WorkflowError) return writeWorkflowError(res, error);
       return writeQccError(res, error);
     }
   });

package/lib/workflow-contract.js

@@ -88,7 +88,7 @@ const TRANSITIONS = Object.freeze({
   export_ready: ['enriching', 'completed', 'failed', 'cancelled'],
   parse_failed: ['draft', 'uploaded', 'cancelled'],
   authorization_required: ['matching', 'enriching', 'failed', 'cancelled'],
-  partial: ['review_required', 'enriching', 'export_ready', 'authorization_required', 'completed', 'failed', 'cancelled'],
+  partial: ['matching', 'review_required', 'enriching', 'export_ready', 'authorization_required', 'completed', 'failed', 'cancelled'],
   failed: ['draft', 'uploaded', 'rules_confirmed', 'diagnosed', 'matching', 'enriching', 'cancelled'],
   completed: [],
   cancelled: [],

package/lib/workflow-execution.js

@@ -0,0 +1,74 @@
+import { WorkflowError } from './workflow.js';
+
+// Execution owns finalization: closing a browser must not interrupt result delivery.
+export function createWorkflowExecution({ getWorkflow, artifacts }) {
+  const requireStore = async () => {
+    const store = await getWorkflow();
+    if (!store || !artifacts) throw new WorkflowError('DC_DELIVERY_UNAVAILABLE', 'Host 任务存储或下载服务不可用，请升级 DSH。', 503);
+    return store;
+  };
+  return {
+    async prepare(payload) {
+      const store = await requireStore();
+      const task = await store.require(payload.taskId);
+      if (!['rules_confirmed', 'diagnosed', 'review_required', 'partial'].includes(task.state)) {
+        throw new WorkflowError('DC_EXECUTION_STATE', '请先在工作台确认规则；进行中或已完成任务不能重复启动。', 409);
+      }
+      if (Number(payload.expectedRevision) !== task.revision) throw new WorkflowError('DC_WORKFLOW_REVISION_CONFLICT', '任务已更新，请重新生成说明。', 409);
+      if ((!payload.kind || payload.kind === 'enrich') && !['rules_confirmed', 'diagnosed'].includes(task.state)) {
+        throw new WorkflowError('DC_EXECUTION_STATE', '请通过候选确认或失败重试继续当前任务。', 409);
+      }
+      if (payload.kind && payload.kind !== 'enrich' && payload.runId !== task.qccRunId) throw new WorkflowError('DC_RUN_MISMATCH', '执行结果不属于当前任务。', 409);
+      if (!payload.kind || payload.kind === 'enrich') {
+        if (!Array.isArray(payload.rows) || payload.rows.length !== task.source?.rowCount) throw new WorkflowError('DC_SOURCE_MISMATCH', '任务名单数量不一致，请重新载入。', 409);
+      }
+      if (!task.fieldSelection.length) throw new WorkflowError('DC_FIELDS_REQUIRED', '未选择外部补全字段，请使用本地清洗与导出。', 400);
+      const primary = task.mappings.find((m) => m.targetField === 'company_name')
+        ?? task.mappings.find((m) => m.targetField === 'credit_no')
+        ?? task.mappings.find((m) => m.targetField === 'reg_no');
+      return { ...payload, workflowOwned: true, workflowRevision: task.revision,
+        fieldSelection: task.fieldSelection, headers: task.source?.headers || [],
+        nameField: primary?.sourceField || payload.nameField };
+    },
+    async beforeRun(record) {
+      if (!record.input.workflowOwned) return;
+      const store = await requireStore();
+      const task = await store.require(record.taskId);
+      if (task.revision !== record.input.workflowRevision) throw new WorkflowError('DC_WORKFLOW_REVISION_CONFLICT', '说明已失效，请返回工作台重新生成；未执行查询。', 409);
+      await store.startMatch(task.id, { expectedRevision: task.revision });
+      record.workflowStarted = true;
+    },
+    async failed(record, error) {
+      if (!record.input.workflowOwned || !record.workflowStarted) return;
+      const store = await requireStore();
+      const task = await store.require(record.taskId);
+      if (['completed', 'cancelled', 'failed'].includes(task.state)) return;
+      if (['QCC_AUTH_REQUIRED', 'QCC_NOT_CONNECTED', 'QCC_TOOL_UNAVAILABLE'].includes(error.code)) {
+        await store.requireAuthorization(task.id, { expectedRevision: task.revision });
+      } else {
+        await store.recordFailure(task.id, { expectedRevision: task.revision, code: error.code || 'DC_DELIVERY_FAILED' });
+      }
+    },
+    async complete(record, run) {
+      if (!record.input.workflowOwned) return;
+      const store = await requireStore();
+      let task = await store.require(record.taskId);
+      const s = run.summary || {};
+      const total = Number(s.totalRows ?? run.rows.length);
+      const review = Number(s.ambiguous ?? 0);
+      task = await store.recordMatch(task.id, { expectedRevision: task.revision, qccRunId: run.runId,
+        summary: { total, exact: Number(s.enriched || 0) + Number(s.fieldReview || 0), candidate: review,
+          unresolved: Number(s.unresolved || 0) + Number(s.missingName || 0), failed: Number(s.failed || 0), reviewRequired: review } });
+      if (review) return { state: task.state, artifacts: [], taskId: task.id };
+      task = await store.startEnrichment(task.id, { expectedRevision: task.revision });
+      task = await store.recordEnrichment(task.id, { expectedRevision: task.revision, qccRunId: run.runId,
+        summary: { total, completed: Number(s.enriched || 0), unchanged: Number(s.unresolved || 0) + Number(s.missingName || 0),
+          failed: Number(s.failed || 0), reviewRequired: Number(s.fieldReview || 0), callsUsed: run.audit?.length || 0 } });
+      const bundle = await artifacts.createBundle(task.id, { rows: run.rows, headers: task.source?.headers || run.headers,
+        mappings: task.mappings, fieldSelection: task.fieldSelection,
+        baseName: (task.source?.fileName || task.title).replace(/\.[^.]+$/, '') + '-清洗补全结果' });
+      task = await store.recordExport(task.id, { expectedRevision: task.revision, artifacts: bundle, preservePartial: true });
+      return { state: task.state, artifacts: task.artifacts, taskId: task.id };
+    },
+  };
+}

package/lib/workflow.js

@@ -384,7 +384,7 @@ export class DataCleaningWorkflowStore {
         throw new WorkflowError('DC_WORKFLOW_ARTIFACT_REQUIRED', 'At least one Host artifact reference is required.', 400);
       }
       return {
-        state: 'completed',
+        state: input.preservePartial === true && record.state === 'partial' ? 'partial' : 'completed',
         stage: 'download',
         artifacts: [...record.artifacts, ...artifacts].slice(-20),
         error: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-data-cleaning-agent",
-  "version": "0.8.16",
+  "version": "0.8.17",
   "description": "Data cleaning and data enrichment for CSV/XLSX/JSON enterprise lists in DeepSeek Harness, including spreadsheet cleaning, deduplication, profiling, optional Qichacha MCP and exports.",
   "type": "module",
   "main": "lib/index.js",
@@ -39,6 +39,7 @@
     "docs/RELEASE-0.8.0.md",
     "docs/RELEASE-0.8.1.md",
     "docs/RELEASE-0.8.16.md",
+    "docs/RELEASE-0.8.17.md",
     "docs/TEMPLATE-MAPPING-ACCEPTANCE.md",
     "docs/UI-WORKFLOW-V2.md",
     "docs/UI-WORKFLOW-V2-MIGRATION.md",
@@ -49,7 +50,7 @@
   "scripts": {
     "test:ui": "node scripts/ui-layout-regression.mjs",
     "test": "node --test",
-    "lint": "node --check lib/index.js && node --check lib/engine.js && node --check lib/artifacts.js && node --check lib/image-intake.js && node --check lib/tools.js && node --check lib/skill.js && node --check lib/qcc-field-catalog.js && node --check lib/qcc-phase2.js && node --check lib/qcc-phase3.js && node --check lib/qcc-phase3-batch.js && node --check lib/qcc-phase2-acceptance.js && node --check lib/skill-enrich.js && node --check lib/jobs.js && node --check lib/workflow-contract.js && node --check lib/workflow.js && node --check lib/qcc-safety.js && node --check lib/qcc.js && node --check lib/qcc-command.js && node --check lib/qcc-runs.js && node --check lib/web.js && node --check lib/client.js && node --check scripts/check-readme-version.mjs && node --check scripts/check-market-registration.mjs && node --check scripts/g5-e2e.mjs && node --check scripts/phase3-e2e.mjs && node --check scripts/phase2-acceptance.mjs",
+    "lint": "node --check lib/index.js && node --check lib/engine.js && node --check lib/artifacts.js && node --check lib/image-intake.js && node --check lib/tools.js && node --check lib/skill.js && node --check lib/qcc-field-catalog.js && node --check lib/qcc-phase2.js && node --check lib/qcc-phase3.js && node --check lib/qcc-phase3-batch.js && node --check lib/qcc-phase2-acceptance.js && node --check lib/skill-enrich.js && node --check lib/jobs.js && node --check lib/workflow-contract.js && node --check lib/workflow.js && node --check lib/workflow-execution.js && node --check lib/qcc-safety.js && node --check lib/qcc.js && node --check lib/qcc-command.js && node --check lib/qcc-runs.js && node --check lib/web.js && node --check lib/client.js && node --check scripts/check-readme-version.mjs && node --check scripts/check-market-registration.mjs && node --check scripts/g5-e2e.mjs && node --check scripts/phase3-e2e.mjs && node --check scripts/phase2-acceptance.mjs",
     "docs:check": "node scripts/check-readme-version.mjs",
     "marketing:check": "node scripts/check-marketing.mjs",
     "verify-pack": "node scripts/verify-pack.mjs",