dsh-data-cleaning-agent 0.8.15 → 0.8.17

package/CHANGELOG.md

@@ -4,6 +4,26 @@
 
 ## [Unreleased]
 
+## [0.8.17] - 2026-09-08
+
+### Fixed
+- 提示词向导和工作台统一生成 Host 执行凭证；发送已确认范围后不再重复询问额度、源文件路径或写回确认。
+- Host 在高层工具内完成工作流与新 XLSX/异常清单交付，不依赖对话模型编写脚本或页面持续轮询；原始文件不覆盖。
+- 独立清洗会话切换、刷新可恢复业务归属；侧栏入口重开当前工作台，保存任务绑定以访问下载。持久化绑定仅包含会话 ID 与任务 ID。
+- 版本冲突阻止旧说明再次查询，命令重放幂等；候选歧义仍需人工选择，部分失败提供下载并允许显式重试。
+- 修复后台刷新覆盖任务历史导航，并覆盖 DSH root/session 分离实例的事件交接。
+
+## [0.8.16] - 2026-09-08
+
+### Changed
+- 表格提示词向导展示完整解析清单与空白单元格数，并与右侧工作台统一原列映射、人工候选确认及补全范围。
+- 映射用绿色（自动通过/已确认）、琥珀色（待人工确认）、红色（未匹配）和文字共同标识；已映射字段自动进入补全范围，额外字段选择默认折叠。
+- 允许多个原列经确认映射同一非主体字段，只补空白、保留非空原值；企业名称、信用代码、注册号各保留唯一匹配主列。
+
+### Fixed
+- 修复 Host 草稿回传将新映射的补全范围重置为默认五字段的问题。
+- 生成任务说明前检查前后端协议能力，旧 Host 配新页面时显示中文升级与安全重启指引；不伪造额度确认，不提前执行查询。
+
 ## [0.8.15] - 2026-09-08
 
 - 改善搜索元数据、安装说明、能力边界与四产品互链；无运行时或依赖变更。

package/README.en.md

@@ -8,9 +8,9 @@ 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.15** (stable release)
+> Current source version / 当前源码版本: **0.8.17** (stable release)
 
-This release fixes misleading import errors after a successful upload. Files are parsed automatically, with persistent source, filename, and row-count status; text parsing handles only newly pasted content. The same file can be selected again, failed parsing preserves existing data, and pending pasted content must be parsed or cleared before continuing. Automatic mapping for 128 fields, blank-cell enrichment in original columns, QCC-blue menus, the resizable workbench, and native DSH sending remain unchanged. Existing download artifacts are not rewritten.
+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.
 
 [![CI](https://github.com/duhu2000/dsh-data-cleaning-agent/actions/workflows/ci.yml/badge.svg)](https://github.com/duhu2000/dsh-data-cleaning-agent/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/dsh-data-cleaning-agent)](https://www.npmjs.com/package/dsh-data-cleaning-agent)

package/README.md

@@ -1,13 +1,13 @@
 # dsh-data-cleaning-agent
 
-本次补丁仅更新搜索发现与安装转化文档，运行时能力保持上一版本；发布记录见 [发布说明](docs/RELEASE-0.8.15.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.15
+dsh plugin --profile web add dsh-data-cleaning-agent@0.8.17
 ```
 
 请先满足下文的 DSH、连接器及侧边栏依赖要求；安装后完整停止并重启对应 Profile。
@@ -25,9 +25,9 @@ dsh plugin --profile web add dsh-data-cleaning-agent@0.8.15
 
 > 在 DeepSeek Harness 中清洗、补全、画像企业名单数据的智能体插件：本地 CSV/XLSX/JSON 引擎 + 可选企查查（Qichacha/QCC）MCP 企业数据补全，由企查查（Qichacha/QCC）团队发起并维护。
 >
-> 当前源码版本 / Current source version: **0.8.15**（正式版本）
+> 当前源码版本 / Current source version: **0.8.17**（正式版本）
 
-本版修复文件上传成功后的导入状态误报：文件选择后自动解析，当前来源、文件名和行数持续显示；文本解析仅处理新粘贴内容。支持重新选择同一文件，解析失败保留现有数据，新粘贴内容解析或清空后再进入下一步。保留 128 字段智能映射、原列补空、企查查蓝菜单、可调宽工作台及 DSH 原生发送机制。历史下载文件不自动改写。
+本版上传表格后展示完整清单及空白数量，用绿色、琥珀色、红色及文字区分已通过、待确认和未匹配映射。已映射字段自动纳入补全范围，额外字段默认折叠；多个原列可经确认使用同一非主体字段，分别补空并保留非空原值。修复 Host 草稿重置为默认五字段的问题，增加前后端版本错配提示。生成说明不查询，发送才执行；升级后需完整重启 DSH，历史下载文件不自动改写。
 
 [![CI](https://github.com/duhu2000/dsh-data-cleaning-agent/actions/workflows/ci.yml/badge.svg)](https://github.com/duhu2000/dsh-data-cleaning-agent/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/dsh-data-cleaning-agent)](https://www.npmjs.com/package/dsh-data-cleaning-agent)

package/docs/RELEASE-0.8.16.md

@@ -0,0 +1,24 @@
+# dsh-data-cleaning-agent v0.8.16
+
+## 本版改进
+
+- 提示词向导与右侧工作台统一：上传显示完整分页清单及空白数量，确认原列映射后自动形成补全范围。
+- 映射状态同时提供颜色和文字：绿色已通过、琥珀色待人工确认、红色未匹配。模糊候选不自动当作已确认。
+- 多个原列可确认使用同一非主体字段；查询字段去重，分别补空，保留非空值、0 与 false。企业名称、信用代码、注册号各保留唯一匹配主列。
+- 已映射字段无需重复选择；额外字段目录默认折叠。修复 Host 草稿把新范围覆盖成默认五字段的问题。
+- 草稿生成前检查 Host 协议能力，发现新页面配旧进程时提供中文升级提示；生成不查询，发送才执行。
+
+## 验收与边界
+
+233 项自动化测试通过，深浅色 × 5 种视口的 10 组隔离 React/Chromium 回归通过。使用合成数据，不以此声称已完成真实 QCC 查询或本机安装验收。详见 [映射验收](TEMPLATE-MAPPING-ACCEPTANCE.md)。
+
+本版只改数据清洗补全仓库，不改 AI 填表及共享字段契约包版本。未知或不支持的字段保留原列，不猜测填充。
+
+## 升级与回滚
+
+1. 保存或导出现有任务，备份任务目录，并记录现有精确版本。
+2. 停止对应 DSH Profile，安装：`dsh plugin --profile web add dsh-data-cleaning-agent@0.8.16`。
+3. 完整重启 DSH 并刷新页面；仅刷新浏览器不足以更新旧内存 Host。
+4. 回滚可安装 `dsh-data-cleaning-agent@0.8.15` 并恢复升级前任务副本。旧版不支持新增多列共享字段映射，不能直接用旧版编辑新版多列映射任务。
+
+历史导出文件不会被自动改写。

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/docs/TEMPLATE-MAPPING-ACCEPTANCE.md

@@ -0,0 +1,29 @@
+# 原表补全与统一映射验收（v0.8.16）
+
+本次范围：数据清洗补全的提示词向导与右侧工作台；未修改 AI 填表或共享内核仓库。
+
+## 交互与数据规则
+
+- 表格上传后展示完整分页清单、列数、空白单元格数，并提供原始清单下载。
+- 标准表头及明确别名自动通过（绿色）；歧义与重复列给出候选（琥珀色），人工选择后转绿色；未知字段为未匹配（红色），原列保留。颜色同时配有文字。
+- 已确认映射自动构成补全范围，不再要求重复勾选默认五字段。额外字段目录默认折叠，只用于新增原表之外的字段。
+- 多个原列可人工确认映射同一非主体字段。查询字段去重，结果分别补空，保留非空原值及数值 0、布尔值 false。
+- 企业名称、统一社会信用代码、注册号分别只允许一个匹配主列；一个原列不能同时映射多个字段。
+- 映射阶段只匹配字段语义，不代表企业主体已匹配或字段数据已查询。没有当前目录支持的字段不猜测、不替换为近似口径。
+- 最终任务说明包含原列映射、补空策略、未映射列及额外新增字段。用户仍可在中央对话框编辑，发送才执行查询。
+
+## 回归证据
+
+使用与反馈表头同结构的合成测试数据，不复制客户工作簿到仓库、不调用真实 QCC：
+
+- 23 列、1 行、22 个空白单元格：9 列自动通过；确认重复列、企业状态、行业候选后，15 列映射至 13 个不同输出字段，8 列未匹配保留。
+- 提示词回填后，Host 保存 15 个映射及 13 个字段，不被旧草稿默认五字段覆盖。
+- CSV/XLSX 结果及异常清单覆盖多个原列共享同一补全字段、原值保护与异常行保护。
+- 自动化检查覆盖契约、Host 路由、草稿不需要费用勾选、实际执行边界，以及深浅色 × 5 种视口的真实 React/Chromium 交互。
+- 浏览器验证旧 Host 能力缺失时显示中文版本错配提示，且不创建或执行 QCC 命令。
+
+## 本机升级注意
+
+本次排查发现正在运行的 DSH 进程启动时间早于插件磁盘更新，可能出现新页面配旧内存 Host。新增能力标记 `draftPreparationVersion: 2`、`multipleOutputColumns: true` 用于提前识别这一情况。
+
+发布安装后需先保存或导出现有任务，再重启 DSH 并刷新页面。仅刷新浏览器不能替换内存中的旧 Host。开发验收未安装或重启本机 DSH，也未改动用户源文件。

package/lib/client.js

@@ -949,6 +949,9 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
 .dcAgentMappingPicker input, .dcAgentMappingPicker select { width: 100%; margin-top: 8px; max-width: 100%; min-width: 0; }
 .dcAgentMappingRow .dcAgentButton { max-width: 100%; white-space: normal; overflow-wrap: anywhere; }
 .dcAgentMappingRow small { display: block; margin: 4px 0; overflow-wrap: anywhere; }
+.dcAgentMappingStatus[data-status="confirmed"] { color: light-dark(#15803d, #86efac); }
+.dcAgentMappingStatus[data-status="review"] { color: light-dark(#a16207, #fcd34d); }
+.dcAgentMappingStatus[data-status="unmatched"] { color: light-dark(#b91c1c, #fca5a5); }
 .dcAgentRulesGrid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 8px; }
 .dcAgentFieldGroup { display: grid; gap: 7px; margin-top: 12px; }
 .dcAgentFieldGroupHead { display: flex; align-items: flex-start; justify-content: space-between; gap: 10px; }
@@ -1228,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 可能被禁用；内存态不受影响。
@@ -1328,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 变化并仅清理完全匹配本插件默认文案，或同时命中
@@ -1356,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();
         }
@@ -1403,8 +1428,17 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       }
       lines.push(`清洗要求：${cleanLabels.length ? cleanLabels.join('、') : '仅解析，不自动修改'}。`);
       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('；') || '暂无'}。`);
+        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');
     }
@@ -1463,6 +1497,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       企业地址: ['registered_address', 'mailing_address'], 公司地址: ['registered_address', 'mailing_address'],
       网址: ['contact_official_website'], website: ['contact_official_website'],
       开业时间: ['establish_date'], 开业日期: ['establish_date'],
+      企业状态: ['reg_status'], 所属行业: ['industry_category', 'qcc_industry'],
       行业: ['industry_category', 'qcc_industry'],
       法人: ['legal_rep'], 邮箱: ['contact_preferred_email'], email: ['contact_preferred_email'],
     };
@@ -1471,7 +1506,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
     }
     function mappingRecommendations(headers, fields = [...ENRICHMENT_OPTIONS, ...INPUT_ONLY_MAPPING_OPTIONS]) {
       const rows = (Array.isArray(headers) ? headers : []).map((sourceField) => {
-        const label = normalizeMappingLabel(String(sourceField).replace(/（重复列 \d+）$/, ''));
+        const label = normalizeMappingLabel(String(sourceField).replace(/（重复列 \d+）$/, '').replace(/\s*YYYY[-/]MM[-/]DD\s*$/i, ''));
         let candidates = fields.filter(([id, name]) => [id, name].some((value) => normalizeMappingLabel(value) === label));
         let reason = '标准字段名匹配';
         if (!candidates.length) {
@@ -1506,10 +1541,23 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       return output;
     }
 
+    const isAnchorField = (id) => ['company_name', 'credit_no', 'reg_no'].includes(id);
+    function mappedOutputFields(mappings) {
+      return [...new Set(mappings.map((item) => item.targetField))].filter((id) => ENRICHMENT_OPTIONS.some(([key]) => key === id));
+    }
+    function syncMappedSelection(previous, next, selected) {
+      const old = new Set(mappedOutputFields(previous));
+      return [...new Set([...selected.filter((id) => !old.has(id)), ...mappedOutputFields(next)])];
+    }
+    function updateColumnMapping(mappings, sourceField, targetField) {
+      if (isAnchorField(targetField) && mappings.some((item) => item.sourceField !== sourceField && item.targetField === targetField)) return mappings;
+      return [...mappings.filter((item) => item.sourceField !== sourceField), ...(targetField ? [{ sourceField, targetField }] : [])];
+    }
+
     function MappingPicker({ sourceField, mappings, groups, recommendation, onChange }) {
       const [query, setQuery] = react.useState('');
       const value = mappings.find((item) => item.sourceField === sourceField)?.targetField || '';
-      const occupied = (id) => mappings.some((item) => item.sourceField !== sourceField && item.targetField === id);
+      const occupied = (id) => isAnchorField(id) && mappings.some((item) => item.sourceField !== sourceField && item.targetField === id);
       const fields = groups.flatMap(([, , items]) => items);
       const label = fields.find(([id]) => id === value)?.[1] || '不参与匹配 / 补全';
       const matches = (id, name) => normalizeMappingLabel([id, name, ...(MAPPING_ALIASES[id] || [])].join(' ')).includes(normalizeMappingLabel(query));
@@ -1535,7 +1583,9 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
             ),
             query && !fields.some(([id, name]) => matches(id, name)) ? h('p', { className: 'dcAgentHint', role: 'status' }, '无匹配字段；当前选择保持不变。') : null,
           ),
-          h('small', { className: 'dcAgentHint' }, value ? `已映射：${label}；可手动调整` : recommendation.reason),
+          h('small', { className: 'dcAgentMappingStatus', 'data-status': value ? 'confirmed' : recommendation.candidates.length ? 'review' : 'unmatched',
+            style: { display: 'block', padding: '6px 0' } },
+            value ? `${recommendation.automatic && recommendation.candidates[0]?.[0] === value ? '自动通过' : '已确认'}：${label}；可手动调整` : recommendation.candidates.length ? `待人工确认：${recommendation.conflict ? '重复列可确认使用同一补全字段；主体标识只选一列' : recommendation.reason}` : '未匹配：保留原列，可手动选择字段'),
           !value && recommendation.candidates.length ? h('div', { className: 'dcAgentRow', 'aria-label': `${sourceField} 推荐映射` }, recommendation.candidates.map(([id, name]) =>
             h('button', { key: id, type: 'button', className: 'dcAgentButton', disabled: occupied(id), onClick: () => onChange(sourceField, id) }, `推荐：${name}${occupied(id) ? '（已占用）' : ''}`))) : null,
         ),
@@ -1546,8 +1596,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       const sourceHeaders = [...new Set(headers)];
       const selected = [...new Set(fieldSelection)];
       const pairs = mappings.filter((item) => sourceHeaders.includes(item.sourceField) && selected.includes(item.targetField)
-        && mappings.filter((other) => other.sourceField === item.sourceField).length === 1
-        && mappings.filter((other) => other.targetField === item.targetField).length === 1);
+        && mappings.filter((other) => other.sourceField === item.sourceField).length === 1);
       const hidden = new Set(pairs.filter((item) => item.sourceField !== item.targetField && !sourceHeaders.includes(item.targetField)).map((item) => item.targetField));
       const blank = (value) => value == null || (typeof value === 'string' && value.trim() === '');
       const output = rows.map((row) => {
@@ -1636,11 +1685,12 @@ 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);
+      if (Array.isArray(task.mappings)) actions.setMappings(task.mappings);
       if (Array.isArray(task.fieldSelection)) actions.setFieldSelection(task.fieldSelection);
-      if (Array.isArray(task.mappings) && task.mappings.length) actions.setMappings(task.mappings);
       return task;
     }
 
@@ -1666,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);
     }
 
@@ -1722,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({
@@ -1776,11 +1896,14 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           setWorkflowTask: (draft, value) => { draft.workflowTask = value ?? null; },
           setWorkflowTasks: (draft, value) => { draft.workflowTasks = Array.isArray(value) ? value : []; },
           setTaskTitle: (draft, value) => { draft.taskTitle = String(value ?? ''); },
-          setMappings: (draft, value) => { draft.mappings = Array.isArray(value) ? value : []; },
+          setMappings: (draft, value) => {
+            const next = Array.isArray(value) ? value : [];
+            draft.fieldSelection = syncMappedSelection(draft.mappings, next, draft.fieldSelection);
+            draft.mappings = next;
+          },
           setMapping: (draft, sourceField, targetField) => {
-            if (targetField && draft.mappings.some((item) => item.sourceField !== sourceField && item.targetField === targetField)) return;
-            const mappings = draft.mappings.filter((item) => item.sourceField !== sourceField);
-            if (targetField) mappings.push({ sourceField, targetField });
+            const mappings = updateColumnMapping(draft.mappings, sourceField, targetField);
+            draft.fieldSelection = syncMappedSelection(draft.mappings, mappings, draft.fieldSelection);
             draft.mappings = mappings;
           },
           setObjectives: (draft, value) => { draft.objectives = Array.isArray(value) ? value : []; },
@@ -1915,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
@@ -2011,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 测试降级。
@@ -2028,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'
@@ -2055,6 +2192,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       if (rootWorkbenchActions) {
         rootWorkbenchActions.setTaskTitle(draft.title);
         rootWorkbenchActions.setObjectives(draft.objectives);
+        if (draft.mappings) rootWorkbenchActions.setMappings(draft.mappings);
         rootWorkbenchActions.setFieldSelection(draft.fieldSelection);
       }
     }
@@ -2456,6 +2594,8 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       const [entries, setEntries] = react.useState([]);
       const [entryCount, setEntryCount] = react.useState(0);
       const [spreadsheetFileName, setSpreadsheetFileName] = react.useState('');
+      const [spreadsheetData, setSpreadsheetData] = react.useState(null);
+      const [spreadsheetMappings, setSpreadsheetMappings] = react.useState([]);
       const [imageFileName, setImageFileName] = react.useState('');
       const [imageSizeBytes, setImageSizeBytes] = react.useState(0);
       const [imageAttachment, setImageAttachment] = react.useState(null);
@@ -2593,14 +2733,19 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           setEntries(extracted);
           setEntryCount(Number.isFinite(result.rowCount) ? result.rowCount : (Array.isArray(result.rows) ? result.rows.length : extracted.length));
           setSpreadsheetFileName(file.name);
+          setSpreadsheetData(result);
+          const suggested = guessMappings(result.headers || []);
+          setSpreadsheetMappings(suggested);
+          setEnrichmentKeys(mappedOutputFields(suggested));
+          setAnchorKeys(suggested.filter((item) => isAnchorField(item.targetField)).map((item) => item.targetField));
           requestWorkbenchDataset(result, sessionId, {
             type: result.fmt || 'xlsx', fileName: file.name, sizeBytes: file.size || 0,
           });
         } catch (fileError) {
+          setSpreadsheetData(null); setSpreadsheetMappings([]); setSpreadsheetFileName(''); setEntries([]); setEntryCount(0);
           setError(fileError instanceof Error ? fileError.message : String(fileError));
         } finally {
           setBusy(false);
-          if (event.target) event.target.value = '';
         }
       };
       const selectedEntries = () => mode === 'text'
@@ -2626,10 +2771,11 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         enrichmentKeys,
         anchorKeys,
         matchRules,
+        ...(mode === 'excel' ? { headers: spreadsheetData?.headers || [], mappings: spreadsheetMappings } : {}),
         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; }
@@ -2649,25 +2795,33 @@ 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 || '待解析'} 条`,
           objectives: cleaningKeys,
           fieldSelection: enrichmentKeys,
           matchRules,
+          ...(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(() => {
@@ -2737,6 +2891,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           event.preventDefault();
           discardCurrentImage();
           setMode('text'); setRawText(''); setEntries([]); setEntryCount(0); setSpreadsheetFileName('');
+          setSpreadsheetData(null); setSpreadsheetMappings([]);
           setCleaningKeys(DEFAULT_CLEANING_KEYS); setEnrichmentKeys(DEFAULT_ENRICHMENT_KEYS);
           setAnchorKeys(['company_name', 'credit_no']);
           setPromptMatchRules({ normalizeNames: true, preferCreditNo: true, deduplicate: true, manualReviewAmbiguous: true });
@@ -2776,7 +2931,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         const groupIds = new Set(fields.map(([id]) => id));
         const selected = new Set(enrichmentKeys);
         for (const id of groupIds) {
-          if (enabledGroup) selected.add(id); else selected.delete(id);
+          if (enabledGroup || (mode === 'excel' && mappedOutputFields(spreadsheetMappings).includes(id))) selected.add(id); else selected.delete(id);
         }
         const catalogOrder = FIELD_GROUPS.flatMap(([, , groupFields]) => groupFields.map(([id]) => id));
         setEnrichmentKeys(catalogOrder.filter((id) => selected.has(id)));
@@ -2884,11 +3039,30 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
                 ? h('b', null, `${mode === 'excel' ? spreadsheetFileName : imageFileName}${mode === 'excel' ? ` · ${entryCount} 条` : ' · 已附加'}`)
                 : null,
             ),
+            mode === 'excel' && spreadsheetData ? h(DatasetReview, {
+              rows: spreadsheetData.rows || [], headers: spreadsheetData.headers || [],
+              title: `已载入：${spreadsheetFileName} · ${entryCount} 条 / ${spreadsheetData.headers?.length || 0} 列`,
+              expectedCount: entryCount, onError: setError,
+            }) : null,
+            mode === 'excel' && spreadsheetData ? h('p', { className: 'dcAgentHint' },
+              `原表空白单元格：${(spreadsheetData.rows || []).reduce((n, row) => n + (spreadsheetData.headers || []).filter((key) => row[key] == null || String(row[key]).trim() === '').length, 0)} 个。下一步确认原列映射；文件已保存在本次任务中。`) : null,
           ) : null,
           wizardStep === 2 ? h('div', { className: 'dcAgentWizardPane' },
             h('h4', null, '确认匹配规则'),
             h('p', null, '强标识优先；名称定位不明确时生成候选，不自动写回。'),
-            h('div', { className: 'dcAgentPromptChoices' }, choice(MATCH_ANCHOR_OPTIONS, anchorKeys, setAnchorKeys)),
+            mode === 'excel' ? h('div', null,
+              h('p', { className: 'dcAgentHint' }, '绿色＝自动通过 / 已确认；黄色＝待人工确认；红色＝未匹配。这里是原列与字段的映射，不是企业查询结果。确认映射即选入补全范围，无需再重复勾选。'),
+              mappingRecommendations(spreadsheetData?.headers || []).map((recommendation) => h(MappingPicker, {
+                key: recommendation.sourceField, sourceField: recommendation.sourceField, mappings: spreadsheetMappings,
+                groups: [...FIELD_GROUPS, ['input-only', '输入校验字段', INPUT_ONLY_MAPPING_OPTIONS]], recommendation,
+                onChange: (sourceField, targetField) => {
+                  const next = updateColumnMapping(spreadsheetMappings, sourceField, targetField);
+                  setEnrichmentKeys(syncMappedSelection(spreadsheetMappings, next, enrichmentKeys));
+                  setSpreadsheetMappings(next);
+                  setAnchorKeys(next.filter((item) => isAnchorField(item.targetField)).map((item) => item.targetField));
+                },
+              })),
+            ) : h('div', { className: 'dcAgentPromptChoices' }, choice(MATCH_ANCHOR_OPTIONS, anchorKeys, setAnchorKeys)),
             h('div', { className: 'dcAgentPromptRules' },
               [['normalizeNames', '匹配前统一企业名称格式'], ['preferCreditNo', '有信用代码时优先精确匹配'], ['deduplicate', '匹配前合并重复主体'], ['manualReviewAmbiguous', '多候选必须人工确认']].map(([key, label]) => h('label', { key },
                 h('input', { type: 'checkbox', checked: matchRules[key], onChange: (event) => setPromptMatchRules({ ...matchRules, [key]: event.target.checked }) }), label,
@@ -2897,11 +3071,14 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           ) : null,
           wizardStep === 3 ? h('div', { className: 'dcAgentWizardPane' },
             h('h4', null, '选择清洗目标和补全字段'),
-            h('p', null, '共 128 个一企一行字段：基础 30、第一批 40、第二批 58。最终可用字段以当前用户连接的 QCC MCP 能力为准。'),
+            h('p', null, `共 ${ENRICHMENT_OPTIONS.length} 个一企一行字段。最终可用字段以当前用户连接的 QCC MCP 能力为准。`),
+            mode === 'excel' ? h('p', { className: 'dcAgentHint' }, `已按确认映射选择 ${mappedOutputFields(spreadsheetMappings).length} 个原列补全字段，无需重复选择。以下仅用于追加原表之外的字段；默认只补空白、保留原值。`) : null,
             h('div', { className: 'dcAgentPromptGroup' },
               h('b', null, '清洗目标'),
               h('div', { className: 'dcAgentPromptChoices' }, choice(CLEANING_OPTIONS, cleaningKeys, setCleaningKeys)),
             ),
+            h('details', { className: 'dcAgentExtraFields', open: mode !== 'excel' },
+            h('summary', null, `可选：追加补全字段（共 ${ENRICHMENT_OPTIONS.length} 项）`),
             h('label', { className: 'dcAgentPromptField' },
               h('span', null, `查找补全字段 · 已选 ${enrichmentKeys.length}`),
               h('input', { type: 'search', className: 'dcAgentField', value: fieldQuery, 'aria-label': '查找补全字段',
@@ -2920,10 +3097,11 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
               ),
               h('div', { className: 'dcAgentPromptFieldGrid' }, visibleCatalogFields([groupId, label, fields, sourceTool], fieldQuery).map(([id, fieldLabel]) => h('label', {
                 key: id, className: `dcAgentPromptChoice${enrichmentKeys.includes(id) ? ' is-selected' : ''}`,
-              }, h('input', { type: 'checkbox', checked: enrichmentKeys.includes(id),
+              }, h('input', { type: 'checkbox', checked: enrichmentKeys.includes(id), disabled: mode === 'excel' && mappedOutputFields(spreadsheetMappings).includes(id),
                 onChange: (event) => setEnrichmentKeys((current) => event.target.checked ? [...new Set([...current, id])] : current.filter((key) => key !== id)),
               }), fieldLabel))),
             )),
+            ),
           ) : null,
           wizardStep === 4 ? h('div', { className: 'dcAgentWizardPane' },
             h('h4', null, '确认任务描述'),
@@ -3118,6 +3296,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         ?? 'name';
       actions.setNameField(guessedNameField);
       actions.setMappings(mappings);
+      if (result.fmt !== 'text') actions.setFieldSelection(mappedOutputFields(mappings));
       actions.setDataset({
         fmt: result.fmt ?? 'csv',
         headers: runtime.headers,
@@ -3128,7 +3307,10 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
     }
 
     async function persistParsedWorkflow(actions, sessionId, result, source = {}, task) {
-      let current = await ensureEditableWorkflowTask(actions, sessionId, {}, task);
+      const importedMappings = guessMappings(result.headers || []);
+      const importedDraft = { mappings: importedMappings,
+        fieldSelection: result.fmt === 'text' ? DEFAULT_ENRICHMENT_KEYS : mappedOutputFields(importedMappings) };
+      let current = await ensureEditableWorkflowTask(actions, sessionId, importedDraft, task);
       const stagingKey = `session:${sessionId || 'unassigned'}`;
       moveRuntime(stagingKey, current.id);
       // handleParse 可能先把新数据写入旧 task runtime。无论是否新建 taskId，
@@ -3154,6 +3336,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           },
         });
       }
+      if (current.state === 'uploaded') current = await updateWorkflowTask(actions, sessionId, current, importedDraft);
       return current;
     }
 
@@ -3287,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 ?? {};
@@ -3294,6 +3485,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           if (detail.sessionId) actions.setActiveSession(detail.sessionId);
           if (draft.title) actions.setTaskTitle(draft.title);
           if (draft.objectives) actions.setObjectives(draft.objectives);
+          if (draft.mappings) actions.setMappings(draft.mappings);
           if (draft.fieldSelection) actions.setFieldSelection(draft.fieldSelection);
           for (const [key, value] of Object.entries(draft.matchRules || {})) actions.setMatchRule(key, value);
           void queueWorkflowOperation(detail.sessionId, async () => {
@@ -3305,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;
@@ -3324,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 中的五个入口在窄桌面视口仍可见、可点击。展开态专注工作台，
       // 不强行挤压到不足一栏的剩余区域。
@@ -3555,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) {
@@ -3595,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;
@@ -3612,36 +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 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;
       };
 
@@ -3769,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);
@@ -3900,7 +4108,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       const setWorkbenchFieldGroup = (fields, enabledGroup) => {
         const selected = new Set(fieldSelection);
         for (const [id] of fields) {
-          if (enabledGroup) selected.add(id); else selected.delete(id);
+          if (enabledGroup || mappedOutputFields(mappings).includes(id)) selected.add(id); else selected.delete(id);
         }
         const catalogOrder = uiFieldGroups.flatMap(([, , groupFields]) => groupFields.map(([id]) => id));
         actions.setFieldSelection(catalogOrder.filter((id) => selected.has(id)));
@@ -3947,7 +4155,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           h('section', { className: 'dcAgentSection' },
             h('h3', null, '字段映射'),
             h('p', { className: 'dcAgentHint' }, '至少映射企业名称、统一社会信用代码或注册号其中一项。未映射列会原样保留，但不参与匹配。'),
-            h('p', { className: 'dcAgentHint' }, `已映射 ${mappings.length} / ${dataset?.headers?.length || 0} 列。标准字段名和明确别名自动匹配；多义表头、重复列请确认推荐。仅在本机匹配表头，不调用模型或企查查，不改变下方输出字段。`),
+            h('p', { className: 'dcAgentHint' }, `已映射 ${mappings.length} / ${dataset?.headers?.length || 0} 列。绿色＝通过；黄色＝待确认；红色＝未匹配。确认映射自动选入补全范围，不调用模型或企查查。多个原列可确认使用同一补全字段，主体匹配标识只选一列。`),
             h('button', { type: 'button', className: 'dcAgentButton', onClick: () => actions.setMappings(mergeRecommendedMappings(dataset?.headers || [], mappings, targetFields)) }, '补充自动映射（保留已有选择）'),
             mappingHints.map((recommendation, index) => h(MappingPicker, {
               key: `${index}:${recommendation.sourceField}`, sourceField: recommendation.sourceField,
@@ -3970,8 +4178,11 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
             ),
           ),
           h('section', { className: 'dcAgentSection' },
-            h('h3', null, `输出字段 · 已选 ${fieldSelection.length}`),
+            h('h3', null, `补全范围 · 已选 ${fieldSelection.length}（映射自动带入 ${mappedOutputFields(mappings).length}）`),
+            h('p', { className: 'dcAgentHint' }, '已映射字段无需重复勾选；如需取消，请调整上方映射。以下可选目录用于追加字段。'),
             h('p', { className: 'dcAgentHint' }, '补全结果优先填入已映射原列的空白单元格，保留非空原值；没有对应映射列的已选字段新增列。重复或多义列请先确认映射。'),
+            h('details', { className: 'dcAgentExtraFields' },
+            h('summary', null, `可选：追加补全字段（共 ${targetFields.filter(([id]) => id !== 'phone').length} 项）`),
             h('div', { className: 'dcAgentRow', 'aria-label': '补全字段批次概览' },
               h('span', { className: 'dcAgentChip' }, '基础字段 30'),
               h('span', { className: 'dcAgentChip' }, '第一批 40'),
@@ -3993,9 +4204,10 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
                 ),
               ),
               h('div', { className: 'dcAgentChips' }, visibleCatalogFields([groupId, label, fields, sourceTool], fieldQuery).map(([key, fieldLabel]) => h('label', { key, className: `dcAgentChip${fieldSelection.includes(key) ? ' is-selected' : ''}` },
-                h('input', { type: 'checkbox', checked: fieldSelection.includes(key), onChange: () => actions.toggleField(key) }), ` ${fieldLabel}`,
+                h('input', { type: 'checkbox', checked: fieldSelection.includes(key), disabled: mappedOutputFields(mappings).includes(key), onChange: () => actions.toggleField(key) }), ` ${fieldLabel}`,
               ))),
             )),
+            ),
           ),
           h('div', { className: 'dcAgentRow' },
             h('button', { type: 'button', className: 'dcAgentButton', disabled: busy, onClick: saveTaskSettings }, '保存草稿'),
@@ -4418,6 +4630,9 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       intakeState,
       projectCompletionResult,
       mappingRecommendations,
+      mappedOutputFields,
+      syncMappedSelection,
+      updateColumnMapping,
       mergeRecommendedMappings,
       MappingPicker,
       deactivateCleaningSession,

package/lib/engine.js

@@ -29,8 +29,7 @@ export function projectCompletionResult({ rows = [], headers = [], mappings = []
   const sourceHeaders = [...new Set(headers)];
   const selected = [...new Set(fieldSelection)];
   const pairs = mappings.filter((item) => sourceHeaders.includes(item.sourceField) && selected.includes(item.targetField)
-    && mappings.filter((other) => other.sourceField === item.sourceField).length === 1
-    && mappings.filter((other) => other.targetField === item.targetField).length === 1);
+    && mappings.filter((other) => other.sourceField === item.sourceField).length === 1);
   const hidden = new Set(pairs.filter((item) => item.sourceField !== item.targetField && !sourceHeaders.includes(item.targetField)).map((item) => item.targetField));
   const blank = (value) => value == null || (typeof value === 'string' && value.trim() === '');
   const output = rows.map((row) => {

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));
@@ -617,6 +619,10 @@ export function mountWebRoutes(wctx, { logger, report, TOOL_NAME, SKILL_NAME })
       capabilities: qccBridge.capabilities(),
       limits: { maxRows: 100, maxConcurrency: 4 },
       paidCallConfirmationRequired: true,
+      draftPreparationVersion: 2,
+      draftPaidCallConfirmationRequired: false,
+      multipleOutputColumns: true,
+      workflowExecutionVersion: 1,
       idempotencyRequired: true,
       candidateResume: true,
       manualRetry: true,
@@ -647,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') {
@@ -662,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: [],
@@ -139,7 +139,7 @@ export function validateMappings(value) {
   const targets = new Set();
   const sources = new Set();
   for (const mapping of mappings) {
-    if (targets.has(mapping.targetField)) {
+    if (MATCH_ANCHORS.includes(mapping.targetField) && targets.has(mapping.targetField)) {
       throw new WorkflowContractError('DC_WORKFLOW_DUPLICATE_MAPPING', `Duplicate target mapping: ${mapping.targetField}`);
     }
     if (sources.has(mapping.sourceField)) {

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.15",
+  "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",
@@ -38,6 +38,9 @@
     "docs/RELEASE-0.7.0.md",
     "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",
     "docs/UI-WORKFLOW-V2-ACCEPTANCE.md",
@@ -47,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",