dsh-data-cleaning-agent 0.8.16 → 0.8.18

package/CHANGELOG.md

@@ -4,6 +4,22 @@
 
 ## [Unreleased]
 
+## [0.8.18] - 2026-09-09
+
+- 新增受益所有人首条名称及首报告期营业总收入、利润总额、总资产，共 136 个字段；共享契约 0.2.0。
+- 映射支持大类与关键词联合筛选，统一十一类排序，保留既有选择。
+- 执行期间同步 Host 任务状态和已处理主体数，展示来源、条目数与补全字段数；状态徽标仅反映当前任务。
+- 工具结果返回真实 XLSX 预览/下载入口，绑定 taskId；安全预览前 50 行，不修改源文件、不重复收费查询。
+
+## [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.18** (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.18.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.18
 ```
 
 请先满足下文的 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.18**（正式版本）
 
 本版上传表格后展示完整清单及空白数量，用绿色、琥珀色、红色及文字区分已通过、待确认和未匹配映射。已映射字段自动纳入补全范围，额外字段默认折叠；多个原列可经确认使用同一非主体字段，分别补空并保留非空原值。修复 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/docs/RELEASE-0.8.18.md

@@ -0,0 +1,15 @@
+# 0.8.18
+
+新增共享首条快照契约（qcc-field-contracts 0.2.0），目录共 136 个字段。
+
+- 受益所有人仅取工具返回首条名称，不代表唯一或最大受益人；不以经营管理人员替代。
+- 财务三项取同一个首返回报告期的主要财务指标，缺项留空，不跨期拼接；保留 0、原始精度、报告期与披露等级。
+- 映射大类与关键词联合筛选，当前选择不因过滤丢失。十一类按工商、联系方式、实控人、受益所有人、简介、财务、税务、上市、进出口、自身风险、关联风险排序。
+- 执行中的任务每秒读取 Host 命令状态与任务元数据。显示来源方式、文件名、输入条数、补全字段数、去重后已处理主体数；已处理不等于成功补全。
+- 对话工具结果包含实际任务的 XLSX 链接：浏览器安全预览前 50 行、下载完整新文件。原上传文件不修改。
+
+## 验证
+
+使用合成返回测试首条规则、缺失和精度；验证原列补空、多列映射及 Host 跨重挂载下载。浏览器回归覆盖明暗主题及五种视口。无真实企查查收费查询。
+
+升级后完整重启 DSH 并重新生成任务说明；旧凭证不改写。

package/lib/artifacts.js

@@ -23,6 +23,7 @@ const SYSTEM_FIELD_LABELS = Object.freeze({
   qcc_match_status: '匹配状态',
   qcc_field_issues: '字段补全待核验原因',
   qcc_source: '数据来源',
+  qcc_snapshot_note: '取值口径与报告期',
   qcc_error: '错误原因',
   match_status: '匹配状态',
   error: '错误原因',

package/lib/client.js

@@ -1141,7 +1141,10 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       ['tax_violation', '税收违法'], ['judgment_debtor', '被执行人'], ['terminated_case', '终本案件'],
       ['equity_freeze', '股权冻结'],
     ];
+    const FIELD_GROUP_ORDER = ['company_registration', 'contact_info', 'actual_controller', 'beneficial_owners', 'company_profile', 'financial_data', 'tax_invoice_info', 'listing_info', 'import_export_credit', 'company_risk_scan', 'company_related_risk_scan'];
     const FIELD_GROUPS = [
+      ['beneficial_owners', '受益所有人', [['beneficial_owner_first_name', '受益所有人名称（首条）']], 'get_beneficial_owners'],
+      ['financial_data', '财务数据', [['financial_total_revenue', '营业总收入'], ['financial_total_profit', '利润总额'], ['financial_total_assets', '总资产']], 'get_financial_data'],
       // Shared contract mirror: checked against qcc-field-contracts in tests.
       ['actual_controller', '实际控制人', [
         ['actual_controller_name', '实际控制人名称'],
@@ -1204,6 +1207,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
         ...RELATED_RISK_KEY_FIELD_OPTIONS.map(([id, label]) => [`related_risk_${id}_party_count`, `关联风险-${label}命中关联方数`]),
       ], 'get_company_related_risk_scan'],
     ];
+    FIELD_GROUPS.sort((a, b) => FIELD_GROUP_ORDER.indexOf(a[0]) - FIELD_GROUP_ORDER.indexOf(b[0]));
     const ENRICHMENT_OPTIONS = FIELD_GROUPS.flatMap(([, , fields]) => fields);
     const INPUT_ONLY_MAPPING_OPTIONS = [['phone', '联系电话']];
     const RESULT_FIELD_LABELS = new Map([
@@ -1231,10 +1235,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 +1352,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 +1382,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 +1434,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');
     }
@@ -1453,6 +1480,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
     }
 
     const MAPPING_ALIASES = {
+      beneficial_owner_first_name: ['首条受益所有人名称'],
       actual_controller_name: ['实控人', '实际控制人', '企业实控人名称', '企业实际控制人', '企业实控人名称（自然人请填写姓名）'],
       actual_controller_direct_ratio: ['实际控制人直接持股比例'],
       actual_controller_total_ratio: ['实际控制人总持股比例'],
@@ -1469,6 +1497,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
     };
     // 语义不完全等同：只推荐，绝不冒充精确匹配或发起调用。
     const MAPPING_HINTS = {
+      受益所有人: ['beneficial_owner_first_name'], 受益所有人名称: ['beneficial_owner_first_name'], UBO: ['beneficial_owner_first_name'],
       地址: ['registered_address', 'mailing_address', 'invoice_address'],
       address: ['registered_address', 'mailing_address'],
       企业地址: ['registered_address', 'mailing_address'], 公司地址: ['registered_address', 'mailing_address'],
@@ -1533,6 +1562,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
 
     function MappingPicker({ sourceField, mappings, groups, recommendation, onChange }) {
       const [query, setQuery] = react.useState('');
+      const [category, setCategory] = react.useState('');
       const value = mappings.find((item) => item.sourceField === sourceField)?.targetField || '';
       const occupied = (id) => isAnchorField(id) && mappings.some((item) => item.sourceField !== sourceField && item.targetField === id);
       const fields = groups.flatMap(([, , items]) => items);
@@ -1548,6 +1578,9 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
             }
           } },
             h('summary', { className: 'dcAgentField', 'aria-label': `${sourceField} 当前映射` }, label),
+            h('select', { className: 'dcAgentField', value: category, 'aria-label': `${sourceField} 映射大类`, onChange: (event) => setCategory(event.target.value) },
+              h('option', { value: '' }, '全部维度'),
+              groups.map(([id, title]) => h('option', { key: id, value: id }, title))),
             h('input', { className: 'dcAgentField', value: query, placeholder: '搜索字段名称 / 英文键 / 别名', 'aria-label': `${sourceField} 搜索映射字段`, onChange: (event) => setQuery(event.target.value) }),
             h('select', { className: 'dcAgentField', value, 'aria-label': `${sourceField} 字段映射`, onChange: (event) => {
               onChange(sourceField, event.target.value);
@@ -1555,11 +1588,12 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
               if (details) { details.open = false; details.querySelector('summary')?.focus(); }
             } },
               h('option', { value: '' }, '不参与匹配 / 补全'),
-              groups.map(([id, title, items]) => h('optgroup', { key: id, label: title }, items.filter(([key, name]) => key === value || matches(key, name)).map(([key, name]) =>
+              groups.filter(([id, , items]) => !category || id === category || items.some(([key]) => key === value)).map(([id, title, items]) => h('optgroup', { key: id, label: title }, items.filter(([key, name]) => key === value || ((!category || category === id) && matches(key, name))).map(([key, name]) =>
                 h('option', { key, value: key, disabled: occupied(key) }, `${name}${occupied(key) ? '（已被其他列使用）' : ''}`)))),
             ),
-            query && !fields.some(([id, name]) => matches(id, name)) ? h('p', { className: 'dcAgentHint', role: 'status' }, '无匹配字段；当前选择保持不变。') : null,
+            (query || category) && !groups.filter(([id]) => !category || id === category).flatMap(([, , items]) => items).some(([id, name]) => matches(id, name)) ? h('p', { className: 'dcAgentHint', role: 'status' }, '无匹配字段；当前选择保持不变。') : null,
           ),
+          value === 'beneficial_owner_first_name' || value.startsWith('financial_') ? h('p', { className: 'dcAgentHint' }, value === 'beneficial_owner_first_name' ? '仅取返回首条受益所有人，不代表唯一或最大受益人。' : '取返回首个报告期，不跨期补值；报告期保留在结果取值说明中。') : null,
           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}` : '未匹配：保留原列，可手动选择字段'),
@@ -1647,10 +1681,11 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       return requestJson(path, body === undefined ? 'GET' : 'POST', body);
     }
 
-    async function waitForQccCommand(commandId, attempts = 180) {
+    async function waitForQccCommand(commandId, attempts = 180, onStatus) {
       for (let attempt = 0; attempt < attempts; attempt += 1) {
         const response = await api(`/data-cleaning/api/g5/commands/${encodeURIComponent(commandId)}`);
         const command = response?.command;
+        await onStatus?.(command);
         if (command?.state === 'completed' || command?.state === 'failed') return command;
         await new Promise((resolve) => setTimeout(resolve, 1000));
       }
@@ -1662,6 +1697,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 +1728,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 +1791,73 @@ 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, async (status) => {
+        if (!status || status.state === 'prepared') return;
+        await refreshHostedTask(actions, sessionId, command.taskId, null, true).catch(() => {});
+        if (isCleaningSession(sessionId) && workflowTaskBySession.get(String(sessionId))?.id === command.taskId) actions.setCommandProgress?.({ taskId: command.taskId, ...status.progress });
+      }).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({
@@ -1799,6 +1909,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
           setError: (draft, error) => { draft.error = error; },
           setInput: (draft, input) => { draft.input = input; },
           setWorkflowContract: (draft, value) => { draft.workflowContract = value; },
+          setCommandProgress: (draft, value) => { draft.commandProgress = value; },
           setWorkflowTask: (draft, value) => { draft.workflowTask = value ?? null; },
           setWorkflowTasks: (draft, value) => { draft.workflowTasks = Array.isArray(value) ? value : []; },
           setTaskTitle: (draft, value) => { draft.taskTitle = String(value ?? ''); },
@@ -1944,6 +2055,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 +2156,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 +2174,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 +2792,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 +2812,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 +2825,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(() => {
@@ -3314,6 +3446,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
       const selectedDomains = useStore((state) => state.selectedDomains);
       const qccCapabilities = useStore((state) => state.qccCapabilities);
       const qccRun = useStore((state) => state.qccRun);
+      const commandProgress = useStore((state) => state.commandProgress);
       const paidConfirmed = useStore((state) => state.paidConfirmed);
       const jobs = useStore((state) => state.jobs);
       const activeSessionId = useStore((state) => state.activeSessionId);
@@ -3355,6 +3488,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 +3515,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 +3536,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 +3787,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 +3831,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 +3850,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 +3985,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);
@@ -4321,7 +4474,7 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
                 className: 'dcAgentQccBadge',
                 title: qccRun ? `任务 ${qccRun.runId}` : '仅在当前用户确认使用自己的企查查账号后调用',
               }, qccRun ? `QCC · ${qccRun.state}` : qccCapabilities ? (qccCapabilities.capabilities?.ready ? 'QCC · 工具已就绪' : 'QCC · 能力不完整') : 'QCC · 自动校验'),
-              h('span', { className: 'dcAgentJobsPill', 'data-state': jobsPill(jobs).state, title: '后台任务状态' }, jobsPill(jobs).label),
+              h('span', { className: 'dcAgentJobsPill', 'data-state': cachedTask?.state || 'idle', title: '当前清洗任务状态' }, cachedTask ? WORKFLOW_STATE_LABELS[cachedTask.state] || cachedTask.state : '尚未开始'),
               h('button', {
                 className: 'dcAgentWbClose',
                 type: 'button',
@@ -4360,6 +4513,12 @@ body:has(.dcAgentPromptBackdrop) { overflow: hidden; }
             h('span', { className: 'dcAgentStepLabel' }, st.label))),
           ) : null,
           h('div', { className: 'dcAgentWbBody' },
+            cachedTask && step !== 'history' ? h('section', { className: 'dcAgentSection', 'aria-label': '当前任务进展', 'aria-live': 'polite' },
+              h('b', null, WORKFLOW_STATE_LABELS[cachedTask.state] || cachedTask.state),
+              h('p', { className: 'dcAgentHint' }, `任务：${cachedTask.id}`),
+              h('p', null, `${cachedTask.source?.type === 'image' ? '图片识别' : cachedTask.source?.type === 'text' ? '粘贴名单' : '上传表格'} · ${cachedTask.source?.fileName || ''} · ${cachedTask.source?.rowCount || 0} 条 · ${cachedTask.fieldSelection?.length || 0} 个补全字段`),
+              commandProgress?.taskId === cachedTask.id && Number.isFinite(commandProgress.totalUnique) ? h('p', null, `已处理主体 ${commandProgress.completedUnique}/${commandProgress.totalUnique}（去重后，含未匹配或失败）`) : null,
+            ) : null,
             error ? h('div', { className: 'dcAgentError', role: 'alert' }, error) : null,
             step !== 'history' ? h('details', { className: 'dcAgentSection' },
               h('summary', null, '使用说明与任务流程'),

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) {
@@ -98,12 +104,17 @@ export function serializeQccCommandPrompt(command) {
     `安全任务凭证：${command.commandId}`,
     '',
     `发送本说明后，请仅调用一次数据清洗补全执行工具（${TOOL_QCC_COMMAND}），参数只传递上述安全任务凭证。`,
+    '完成后请在对话中列出工具返回的 XLSX 文件名、预览和下载链接；只使用实际返回的链接，不编造文件或要求源文件路径。',
     '不要要求重复粘贴企业名单，不要直接调用 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 +122,7 @@ export class QccCommandStore {
     this.ttlMs = ttlMs;
     this.maxCommands = maxCommands;
     this.commands = new Map();
+    this.lifecycle = lifecycle;
   }
 
   cleanup(reserveSlot = false) {
@@ -171,6 +183,9 @@ export class QccCommandStore {
       runId: record.runId,
       error: record.error,
       estimate: record.estimate,
+      progress: record.progress ?? null,
+      workflowOwned: record.input.workflowOwned === true,
+      delivery: record.delivery ?? null,
       expiresInMs: this.ttlMs,
     });
   }
@@ -190,15 +205,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();
@@ -217,6 +235,7 @@ export class QccCommandStore {
       return this.runs.retryCompanies(record.input.runId, record.input.companyNames, this.bridge, options);
     }
     const audit = [];
+    record.progress = { completedUnique: 0, totalUnique: record.estimate?.uniqueCompanies || 0 };
     const result = await this.bridge.enrichRows(record.input.rows, {
       nameField: record.input.nameField,
       includeRisk: record.input.includeRisk,
@@ -225,6 +244,7 @@ export class QccCommandStore {
       maxRows: 100,
       execution,
       onAudit: (event) => audit.push(event),
+      onProgress: (progress) => { record.progress = progress; },
     });
     return this.runs.createRun({
       headers: record.input.headers,
@@ -244,6 +264,8 @@ export class QccCommandStore {
       runId: run.runId,
       state: run.state,
       summary: run.summary,
+      ...(record.delivery ? { deliveryState: record.delivery.state, artifactCount: record.delivery.artifacts.length,
+        artifacts: record.delivery.artifacts.filter(a => a.format === 'xlsx').map(a => ({ fileName: a.fileName, url: `/data-cleaning/api/workflow/tasks/${encodeURIComponent(record.taskId)}/artifacts/${encodeURIComponent(a.id)}` })) } : {}),
     });
   }
 }
@@ -267,6 +289,9 @@ export function registerQccCommandTool(tools, commands) {
           taskId: { type: 'string' },
           runId: { type: 'string' },
           state: { type: 'string' },
+          deliveryState: { type: 'string' },
+          artifactCount: { type: 'integer' },
+          artifacts: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { fileName: { type: 'string' }, url: { type: 'string' } }, required: ['fileName', 'url'] } },
           summary: {
             type: 'object',
             additionalProperties: false,
@@ -288,7 +313,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' ? '存在多候选，请返回工作台确认主体。' : '请返回工作台查看任务状态。'}\n${(value.artifacts || []).map(a => `${String(a.fileName).replace(/[^a-zA-Z0-9\u4e00-\u9fff._ -]/g, '_')}：[预览 / 打开](${a.url}?preview=1) · [下载 Excel](${a.url})`).join('\n')}`,
       }],
     },
     async execute(args, exec) {

package/lib/qcc-field-catalog.js

@@ -5,7 +5,7 @@
  * 任何明细列表（电话全集、海关资质、风险关联方等）都不得进入本目录。
  */
 
-import { ACTUAL_CONTROLLER_GROUP } from 'qcc-field-contracts';
+import { ACTUAL_CONTROLLER_GROUP, SNAPSHOT_GROUPS, SNAPSHOT_GROUP_ORDER } from 'qcc-field-contracts';
 const field = (id, label, options = {}) => Object.freeze({ id, label, ...options });
 const group = (id, label, sourceTool, fields, options = {}) => Object.freeze({
   id,
@@ -175,7 +175,8 @@ export const QCC_FIELD_CATALOG = Object.freeze([
     ...RELATED_RISK_KEY_FACTORS.map(([id, label]) => field(`related_risk_${id}_party_count`, `关联风险-${label}命中关联方数`)),
   ], { releaseBatch: 'batch-2', catalogVersion: RISK_FACTOR_CATALOG_VERSION }),
   ACTUAL_CONTROLLER_GROUP,
-]);
+  ...SNAPSHOT_GROUPS,
+].sort((a, b) => SNAPSHOT_GROUP_ORDER.indexOf(a.id) - SNAPSHOT_GROUP_ORDER.indexOf(b.id)));
 
 export const QCC_FIELD_SOURCE_TOOL = Object.freeze(Object.fromEntries(
   QCC_FIELD_CATALOG.flatMap((entry) => entry.fields.map((item) => [item.id, entry.sourceTool])),

package/lib/qcc-runs.js

@@ -235,6 +235,7 @@ export class G5RunStore {
           qcc_match_status: 'enriched',
           ...(row.qcc_field_issues || result.fieldIssues ? { qcc_field_issues: Object.entries(result.fieldIssues || {}).map(([field, issue]) => field + ': ' + issue.message).join('；') } : {}),
           qcc_source: 'qcc-mcp',
+          ...(result.snapshotNote ? { qcc_snapshot_note: result.snapshotNote } : {}),
         };
       } else {
         record.rows[index] = { ...row, qcc_match_status: result.status };

package/lib/qcc.js

@@ -8,7 +8,7 @@
  * - 批量补全只在 Host/Web 内处理明细；模型仍只接收摘要。
  */
 import { safeAuditEvent } from './qcc-safety.js';
-import { projectActualController } from 'qcc-field-contracts';
+import { projectActualController, projectFirstSnapshot } from 'qcc-field-contracts';
 import {
   QCC_PHASE2_COMPANY_TOOLS,
   QCC_PHASE2_HISTORY_TOOLS,
@@ -558,6 +558,7 @@ export function mapActualControllerFields(value, match) {
   return result.values;
 }
 const SOURCE_TOOL_CONFIG = Object.freeze({
+  ...Object.fromEntries(['get_beneficial_owners', 'get_financial_data'].map(tool => [tool, { name: `mcp__qcc-company__${tool}`, map: data => projectFirstSnapshot(data, tool).values }])),
   get_actual_controller: Object.freeze({ name: QCC_TOOL_NAMES.actualController, map: mapActualControllerFields }),
   get_company_registration_info: Object.freeze({ name: QCC_TOOL_NAMES.registration, map: mapRegistrationFields }),
   get_company_profile: Object.freeze({ name: QCC_TOOL_NAMES.profile, map: mapProfileFields }),
@@ -928,6 +929,7 @@ export class QccHostBridge {
     const sourceTools = sourceToolsForFieldSelection(options.fieldSelection, options.includeRisk);
     let mapped = {};
     const fieldIssues = {};
+    const snapshotNotes = [];
     let legacyRiskTags = '';
     for (const sourceTool of sourceTools) {
       const config = SOURCE_TOOL_CONFIG[sourceTool];
@@ -935,6 +937,11 @@ export class QccHostBridge {
       const response = await this.call(config.name, { searchKey: lockedKey, ...(config.args ?? {}) }, options);
       const fields = config.map(response.data, match);
       mapped = mergeMappedFields(mapped, fields);
+      if (['get_beneficial_owners', 'get_financial_data'].includes(sourceTool)) {
+        const projection = projectFirstSnapshot(response.data, sourceTool);
+        Object.assign(fieldIssues, Object.fromEntries(Object.entries(projection.issues).filter(([id]) => options.fieldSelection?.includes(id))));
+        snapshotNotes.push(sourceTool === 'get_financial_data' ? `get_financial_data：返回首期 ${projection.provenance.reportPeriod || '未返回报告期'}；${projection.provenance.disclosure || '未返回披露等级'}；金额原值未换算` : `get_beneficial_owners：仅取首条；返回 ${projection.provenance.recordCount} 条，不代表唯一受益人`);
+      }
       if (sourceTool === 'get_actual_controller') {
         Object.assign(fieldIssues, Object.fromEntries(Object.entries(projectActualController(response.data).issues)
           .filter(([field]) => options.fieldSelection?.includes(field))));
@@ -958,6 +965,7 @@ export class QccHostBridge {
     const fields = projectSelectedFields(mapped, options.fieldSelection);
     if (options.includeRisk) fields.risk_tags = legacyRiskTags;
     return { status: 'enriched', companyName: String(match?.companyName ?? ''), fields,
+      ...(snapshotNotes.length ? { snapshotNote: snapshotNotes.join('；') } : {}),
       ...(Object.keys(fieldIssues).length ? { fieldIssues } : {}) };
   }
 
@@ -1061,6 +1069,7 @@ export class QccHostBridge {
           ...Object.fromEntries(Object.entries(result.fields || {}).filter(([key]) => row[key] == null || (typeof row[key] === 'string' && row[key].trim() === ''))),
           qcc_match_status: 'enriched',
           qcc_source: 'qcc-mcp',
+          ...(result.snapshotNote ? { qcc_snapshot_note: result.snapshotNote } : {}),
           ...(row.qcc_field_issues || result.fieldIssues ? { qcc_field_issues: Object.entries(result.fieldIssues || {}).map(([field, issue]) => field + ': ' + issue.message).join('；') } : {}),
         };
       }

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));
@@ -557,6 +559,16 @@ export function mountWebRoutes(wctx, { logger, report, TOOL_NAME, SKILL_NAME })
           const artifact = current.artifacts.find((item) => item.id === artifactId);
           if (!artifact) throw new ArtifactError('DC_ARTIFACT_NOT_FOUND', 'Artifact not found for this task.', 404);
           const bytes = await artifactStore.read(taskId, artifact);
+          if (artifact.format === 'xlsx' && new URL(req.url, 'http://127.0.0.1').searchParams.get('preview') === '1') {
+            const parsed = await parseXlsx(bytes);
+            const escape = value => String(value ?? '').replace(/[&<>\"]/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '\"': '&quot;' }[c]));
+            const columns = parsed.headers || [];
+            const rows = (parsed.rows || []).slice(0, 50);
+            const download = `/data-cleaning/api/workflow/tasks/${encodeURIComponent(taskId)}/artifacts/${encodeURIComponent(artifactId)}`;
+            const html = `<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>${escape(artifact.fileName)}</title><style>body{font:14px system-ui;padding:24px;color:#243044}table{border-collapse:collapse}td,th{border:1px solid #dde5ef;padding:8px;min-width:100px;white-space:pre-wrap}th{background:#e5f3ff}a{color:#0875ce}</style><h1>${escape(artifact.fileName)}</h1><p>任务 ${escape(taskId)} · 共 ${artifact.rowCount} 行，预览前 50 行；源文件未修改。</p><a href="${download}">下载完整 Excel</a><table><thead><tr>${columns.map(c => `<th>${escape(c)}</th>`).join('')}</tr></thead><tbody>${rows.map(row => `<tr>${columns.map(c => `<td>${escape(row[c])}</td>`).join('')}</tr>`).join('')}</tbody></table>`;
+            res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', 'content-security-policy': "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'self'", 'x-content-type-options': 'nosniff' });
+            return res.end(html);
+          }
           const fallback = artifact.format === 'xlsx' ? 'export.xlsx' : 'export.csv';
           const asciiName = String(artifact.fileName || fallback).replace(/[^\x20-\x7e]/g, '_').replace(/["\\]/g, '_');
           res.writeHead(200, {
@@ -620,6 +632,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 +663,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 +678,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.18",
   "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,8 @@
     "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/RELEASE-0.8.18.md",
     "docs/TEMPLATE-MAPPING-ACCEPTANCE.md",
     "docs/UI-WORKFLOW-V2.md",
     "docs/UI-WORKFLOW-V2-MIGRATION.md",
@@ -49,7 +51,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",
@@ -116,7 +118,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "qcc-field-contracts": "0.1.0",
+    "qcc-field-contracts": "0.2.0",
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {