weaver-work-cli 0.1.42 → 0.1.44

package/dist/shortcuts/recruit-stage/context.js

@@ -5,6 +5,24 @@ import { homedir } from 'node:os';
 import { createRecruitContextLoader, } from '../ehr/operations/recruit.js';
 import { rsFail } from './errors.js';
 const flowMemo = new Map();
+/**
+ * 自用系统（selfUse=1）默认招聘流程兜底常量 —— 2026-11-05 用户明确指定写死。
+ *
+ * 背景：www.e-cology.com.cn 是自用系统，招聘流程**只有一条**「初筛+面试+offer阶段」。
+ * 该环境的运行时解析通道全部取不到值（实测）：
+ *   · 环境缓存无 defaultRecruitFlow 键、无 menus 字段
+ *   · 原接口 /api/recruit/position/recruitFlow/list 不存在（静默失败）
+ *   · 招聘流程菜单列表经 listInit + getListDatas 仍未返回可用行
+ *
+ * ⚠️ 与技能「环境 id 绝不入包、跨环境自适应」原则冲突，故**加双重守卫**：
+ *   仅当 selfUse=1 且域名等于 selfUseHost 时才使用本常量；其他环境继续走运行时解析，不受影响。
+ *   换环境或该流程数据变更时必须同步修改此处。
+ */
+const SELFUSE_DEFAULT_FLOW = {
+    selfUseHost: 'www.e-cology.com.cn',
+    id: '874896524979806209',
+    name: '初筛+面试+offer阶段',
+};
 const digitalMenuMemo = new Map();
 function cacheDirFor(baseUrl) {
     const url = new URL(baseUrl);
@@ -24,29 +42,63 @@ async function readLegacyCacheExtra(baseUrl) {
         const dir = cacheDirFor(baseUrl);
         if (!existsSync(dir))
             return { defaultRecruitFlow: null, digitalHumanMenu: null };
-        const files = (await import('node:fs/promises')).readdir(dir);
-        const jsonFiles = (await files).filter((f) => f.endsWith('.json'));
-        if (jsonFiles.length !== 1)
-            return { defaultRecruitFlow: null, digitalHumanMenu: null };
-        const raw = JSON.parse(await readFile(join(dir, jsonFiles[0]), 'utf8'));
-        const flow = raw?.defaultRecruitFlow && raw.defaultRecruitFlow.id
-            ? { id: String(raw.defaultRecruitFlow.id), name: String(raw.defaultRecruitFlow.name || '') }
-            : null;
-        const dh = raw?.lists?.digital_human?.listId
-            ? {
-                menuName: String(raw.lists.digital_human.menuName || '面试数字人配置'),
-                listId: String(raw.lists.digital_human.listId),
-                cusMenuId: String(raw.lists.digital_human.cusMenuId || ''),
+        const files = await (await import('node:fs/promises')).readdir(dir);
+        const jsonFiles = files.filter((f) => f.endsWith('.json'));
+        // 原实现要求「目录内恰好 1 个 json 才读」，多环境/多应用共存时必然读不到 →
+        // 改为遍历全部 json，取第一个带所需键的（2026-11-05 修）。
+        let flow = null;
+        let dh = null;
+        for (const f of jsonFiles) {
+            let raw;
+            try {
+                raw = JSON.parse(await readFile(join(dir, f), 'utf8'));
+            }
+            catch {
+                continue;
+            }
+            if (!flow && raw?.defaultRecruitFlow && raw.defaultRecruitFlow.id) {
+                flow = { id: String(raw.defaultRecruitFlow.id), name: String(raw.defaultRecruitFlow.name || '') };
+            }
+            if (!dh && raw?.lists?.digital_human?.listId) {
+                dh = {
+                    menuName: String(raw.lists.digital_human.menuName || '面试数字人配置'),
+                    listId: String(raw.lists.digital_human.listId),
+                    cusMenuId: String(raw.lists.digital_human.cusMenuId || ''),
+                };
             }
-            : null;
+            if (flow && dh)
+                break;
+        }
         return { defaultRecruitFlow: flow, digitalHumanMenu: dh };
     }
     catch {
         return { defaultRecruitFlow: null, digitalHumanMenu: null };
     }
 }
-/** 默认招聘流程解析：招聘设置/流程列表中「默认启用」的那条（运行时解析，跨环境不写死）。 */
-async function resolveDefaultRecruitFlow(host, baseUrl, appId) {
+/** 从菜单树/list 里找「招聘流程」列表参数（本环境实测存在于 lists.all_search） */
+function findFlowMenu(cache) {
+    const all = ((cache.lists || {}).all_search || []);
+    const hit = all.find((m) => m && m.listId && /招聘流程/.test(String(m.menuName || '')));
+    if (hit) {
+        return { listId: String(hit.listId), cusMenuId: String(hit.cusMenuId || ''), menuName: String(hit.menuName || '招聘流程') };
+    }
+    return null;
+}
+/** 判断某行是否为「默认启用」流程：兼容多种字段命名 */
+function isDefaultFlowRow(x) {
+    if (!x)
+        return false;
+    const cands = [x.is_default, x.isDefault, x.default_flow, x.defaultFlow, x.is_enable, x.enabled, x.status];
+    for (const v of cands) {
+        if (v === true || v === 1 || v === '1')
+            return true;
+        if (String(v) === '是' || String(v) === '启用' || String(v) === '默认')
+            return true;
+    }
+    return false;
+}
+/** 默认招聘流程解析：优先 legacy 缓存 → 招聘流程菜单列表 → 旧接口兜底。失败**不缓存**（允许多次重试）。 */
+async function resolveDefaultRecruitFlow(host, baseUrl, appId, cache) {
     const memoKey = baseUrl;
     if (flowMemo.has(memoKey))
         return flowMemo.get(memoKey) ?? null;
@@ -56,24 +108,84 @@ async function resolveDefaultRecruitFlow(host, baseUrl, appId) {
         return legacy.defaultRecruitFlow;
     }
     let result = null;
-    try {
-        // 招聘流程配置（ hire structures ）：优先业务配置通道；接口不可用或为空时保持 null（由摘要标注"未解析到默认流程"）
-        const r = await host.request({
-            path: '/api/recruit/position/recruitFlow/list',
-            method: 'POST',
-            body: { appId, current: 1, pageSize: 50 },
-            operation: 'context.defaultRecruitFlow',
-        });
-        const rows = r?.data?.list || r?.data?.rows || r?.data || [];
-        const list = Array.isArray(rows) ? rows : [];
-        const enabled = list.find((x) => x && (x.isDefault === true || Number(x.isDefault) === 1 || x.default_flow === '1'))
-            || list.find((x) => x && x.id);
-        if (enabled?.id) {
-            result = { id: String(enabled.id), name: String(enabled.name || enabled.flow_name || '') };
+    // ① 招聘流程菜单列表（本环境实测入口，原实现只调接口必然失败）
+    const menu = findFlowMenu(cache);
+    if (menu) {
+        try {
+            // getListDatas 的 passid/cid 必须是**表单 objId**，不是 listId；
+            // 先用 listInit 用 listId 反查 objId（口径同 interview-arrange 的数字人菜单解析）
+            let flowObjId = '';
+            try {
+                const liBody = {
+                    cusMenuId: menu.cusMenuId,
+                    listId: menu.listId,
+                    urlPageTitle: menu.menuName,
+                };
+                liBody['appId_' + menu.listId] = appId;
+                const li = await host.request({ path: '/api/ebuilder/form/list/listInit', body: liBody });
+                flowObjId = String(li?.data?.objid || '');
+            }
+            catch { /* listInit 不可用 → 走接口兜底 */ }
+            if (flowObjId) {
+                const body = {
+                    current: 1, pageSize: 50, tableuid: Math.random().toString(16).slice(2, 34),
+                    listId: menu.listId, searchParamData: { searchType: '3', type: 'and' },
+                    terminal: 'PC', browser: 'Chrome', requiredMatch: 1, mapResult: 1,
+                    recheckQuery: 1, isFollow: 0, isShareToMe: 0, filterCondition: {},
+                    cusMenuId: menu.cusMenuId, urlPageTitle: menu.menuName, menuName: menu.menuName,
+                };
+                const r = await host.request({
+                    path: `/api/ebuilder/form/list/getListDatas?passid=${flowObjId}&cid=${flowObjId}`,
+                    body,
+                    headers: { ebBusinessId: menu.listId },
+                });
+                const rows = (r?.data?.data || r?.data?.displayData || []);
+                const pick = rows.find(isDefaultFlowRow) || (rows.length === 1 ? rows[0] : null);
+                if (pick) {
+                    const id = String(pick.form_data_id || pick.id || '');
+                    const name = String(pick.name || pick.flow_name || pick.content || '');
+                    if (id && name)
+                        result = { id, name };
+                }
+            }
+        }
+        catch { /* 菜单通道不可用 → 走接口兜底 */ }
+    }
+    // ② 旧接口兜底（原实现唯一通道，部分环境保留）
+    if (!result) {
+        try {
+            const r = await host.request({
+                path: '/api/recruit/position/recruitFlow/list',
+                method: 'POST',
+                body: { appId, current: 1, pageSize: 50 },
+                operation: 'context.defaultRecruitFlow',
+            });
+            const rows = r?.data?.list || r?.data?.rows || r?.data || [];
+            const list = Array.isArray(rows) ? rows : [];
+            const enabled = list.find(isDefaultFlowRow) || null;
+            if (enabled?.id) {
+                result = { id: String(enabled.id), name: String(enabled.name || enabled.flow_name || '') };
+            }
+        }
+        catch { /* 接口形态不符/未开放 */ }
+    }
+    // ③ 自用系统兜底（用户指定写死）：仅 selfUse=1 且域名匹配时生效，不影响其他环境
+    if (!result) {
+        const isSelfUse = String(cache?.selfUse || '') === '1';
+        let host = '';
+        try {
+            host = new URL(baseUrl).hostname;
+        }
+        catch {
+            host = '';
+        }
+        if (isSelfUse && host === SELFUSE_DEFAULT_FLOW.selfUseHost) {
+            result = { id: SELFUSE_DEFAULT_FLOW.id, name: SELFUSE_DEFAULT_FLOW.name };
         }
     }
-    catch { /* 接口形态不符/未开放：保持 null，不阻塞建职位 */ }
-    flowMemo.set(memoKey, result);
+    // 只有解析成功才写入 memo：失败若也缓存 null，进程内后续所有请求都拿不到（原实现缺陷）
+    if (result)
+        flowMemo.set(memoKey, result);
     return result;
 }
 async function resolveDigitalHumanMenu(host, baseUrl, cache) {
@@ -102,7 +214,7 @@ export function createRecruitStageContext() {
         const cache = await loaders.get(loaderKey).load(host);
         const baseUrl = (await host.getSession()).baseUrl.replace(/\/+$/, '');
         const [defaultRecruitFlow, digitalHumanMenu] = await Promise.all([
-            resolveDefaultRecruitFlow(host, baseUrl, cache.appId),
+            resolveDefaultRecruitFlow(host, baseUrl, cache.appId, cache),
             resolveDigitalHumanMenu(host, baseUrl, cache),
         ]);
         return { ...cache, defaultRecruitFlow, digitalHumanMenu };

package/dist/shortcuts/recruit-stage/continuation.js

@@ -1,3 +1,4 @@
+import { CONTINUATION_TTL_MS } from '../../core/continuation-ttl.js';
 import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
@@ -35,7 +36,7 @@ function signature(payload, key) {
 }
 export function createRecruitStageContinuationSigner(ctx) {
     return {
-        async issue(payload, ttlMs = 10 * 60_000) {
+        async issue(payload, ttlMs = CONTINUATION_TTL_MS) {
             const issuedAt = Date.now();
             const body = encode({ ...payload, issuedAt, expiresAt: issuedAt + ttlMs });
             const sig = signature(body, await loadKey(ctx));

package/dist/shortcuts/recruit-stage/operations/jd-create.js

@@ -35,9 +35,10 @@ const DATAKEYS_MTEXT = ['position_duty', 'work_request'];
 const DEF_TEXT = { recruit_count: '1', number_of_pay_months: '12' };
 const DEF_OPTION = { salary_type: '月薪', recruit_type: '社会招聘' };
 const DEF_CURRENT_USER = ['recr_principal', 'employ_manager'];
+// 🔴 薪资不继承：历史职位薪资可能是脏数据（实测抓到 300 元月薪），
+// 改为按 references/position-templates.md §1.1 的推荐表由 Agent 填入 sets，未指定就留空。
 const DEF_FROM_REF = [
     'position_nature', 'job_category', 'education', 'work_years', 'work_location',
-    'salary_min', 'salary_max',
 ];
 const DEF_STATUS = '招聘中';
 // sets 覆盖解析：字段取值类别
@@ -115,14 +116,63 @@ function refToSubmit(d) {
         return null;
     return o;
 }
-// 工作地点：按名称/详细地址/城市解析「办公地点」记录 id（tag uf_rcrt_work_place → 表单 → 列表匹配）
+// 工作地点的「办公地点」菜单定位：三级来源，不依赖 cache.menus
+// 实测（2026-11-05）：本环境环境缓存**没有 menus 字段**（只有 forms/lists/fields/dict 等），
+// 原实现直接读 cache.menus → 拿到 undefined → findMenuNode 返回 null → resolveWorkLocation 恒为 null
+// → work_location 每次进 setSkipped（连完整地址都写不进去）。改为：
+//   ① cache.lists.all_search（与面试数字人菜单解析同一模式，已在用）
+//   ② cache.menus（若某环境确实有）
+//   ③ allMenus 接口兜底（resolvePositionNewUrl 已在用，同一写法）
+const WORK_PLACE_NAMES = ['办公地点', '工作地点'];
+async function findWorkPlaceMenu(ctx) {
+    const { host, appId, cache } = ctx;
+    const ok = (m) => m && m.listId;
+    // ① all_search
+    const allSearch = ((cache.lists || {}).all_search || []);
+    const hit1 = allSearch.find((m) => ok(m) && WORK_PLACE_NAMES.some((n) => String(m.menuName || '').includes(n)));
+    if (hit1)
+        return { listId: String(hit1.listId), cusMenuId: String(hit1.cusMenuId || ''), menuName: String(hit1.menuName || '') };
+    // ② cache.menus（可能不存在）
+    const hit2 = findMenuNode(cache.menus || [], WORK_PLACE_NAMES, (m) => ok(m));
+    if (hit2)
+        return { listId: String(hit2.listId), cusMenuId: String(hit2.cusMenuId || ''), menuName: String(hit2.menuName || '') };
+    // ③ allMenus 接口
+    try {
+        const r = await host.request({ path: `/api/cusapp/app/allMenus?isFront=1&appId=${appId}&terminalType=PC`, method: 'GET' });
+        const flat = [];
+        (function walk(ns) { for (const n of (ns || []))
+            if (n && typeof n === 'object') {
+                flat.push(n);
+                walk(n.children || n.childs);
+            } })(r?.data?.cusAppMenus || r?.data);
+        const hit3 = findMenuNode(flat, WORK_PLACE_NAMES, (m) => ok(m));
+        if (hit3)
+            return { listId: String(hit3.listId), cusMenuId: String(hit3.cusMenuId || ''), menuName: String(hit3.menuName || '') };
+    }
+    catch { /* 接口不可用则放弃 */ }
+    return null;
+}
+// 工作地点：按名称/详细地址/城市解析「办公地点」记录 id
 async function resolveWorkLocation(ctx, value) {
     const { host, appId, cache } = ctx;
-    const t = await host.request({ path: `/api/ebuilder/form/obj/getObjsByTag?appId=${appId}&tag=uf_rcrt_work_place`, method: 'GET' });
-    const d = t?.data;
-    const pObj = (Array.isArray(d) && d[0]) ? String(d[0].id || '') : '';
-    const menu = findMenuNode(cache.menus || [], ['办公地点', '工作地点'], (m) => m.listId && m.cusMenuId);
-    if (!pObj || !menu)
+    const v = String(value).trim();
+    if (!v)
+        return null;
+    // objId：优先按 tag 取；取不到时用菜单节点自带的（部分环境 tag 未注册）
+    let pObj = '';
+    try {
+        const t = await host.request({ path: `/api/ebuilder/form/obj/getObjsByTag?appId=${appId}&tag=uf_rcrt_work_place`, method: 'GET' });
+        const d = t?.data;
+        if (Array.isArray(d) && d[0])
+            pObj = String(d[0].id || '');
+    }
+    catch { /* tag 未注册：继续用菜单兜底 */ }
+    const menu = await findWorkPlaceMenu(ctx);
+    if (!menu)
+        return null;
+    if (!pObj)
+        pObj = String(menu.objId || '');
+    if (!pObj)
         return null;
     const body = {
         current: 1, pageSize: 200, tableuid: randHex32(),
@@ -132,10 +182,12 @@ async function resolveWorkLocation(ctx, value) {
         cusMenuId: menu.cusMenuId, urlPageTitle: menu.menuName, menuName: menu.menuName,
     };
     const r = await host.request({ path: `/api/ebuilder/form/list/getListDatas?passid=${pObj}&cid=${pObj}`, body, headers: { ebBusinessId: menu.listId } });
-    const rows = r?.data?.data || [];
-    const v = String(value).trim();
+    // displayData 是服务端翻译后的可读文本；data 为原始行 —— 两者都兜
+    const rows = r?.data?.data || r?.data?.displayData || [];
     const hit = rows.find((x) => {
-        const name = String(x.name || ''), detail = String(x.detail_location || ''), area = String(x.area_text || '');
+        const name = String(x.name || x.detail_location || '');
+        const detail = String(x.detail_location || '');
+        const area = String(x.area_text || '');
         return name.includes(v) || detail.includes(v) || area.includes(v) || (detail && v.includes(detail));
     });
     return hit ? { id: String(hit.form_data_id || hit.id), name: String(hit.detail_location || hit.name || v) } : null;
@@ -391,6 +443,10 @@ async function buildJd(opts) {
             }
         }
     }
+    // 其余必填字段默认值：从「环境内最近一条职位记录」继承
+    // ⚠️ 继承来源可能是脏数据（实测本环境 836 条职位中「蓝堡舟山普陀区蓝堡」占 35 条），
+    // 因此逐个字段记录 inheritedFromRef，在确认摘要里明示，避免用户以为是自己指定的值。
+    const inheritedFromRef = [];
     for (const k of DEF_FROM_REF) {
         const id = fid(k);
         if (id && !map.has(String(id)) && refByFid[String(id)]) {
@@ -398,6 +454,7 @@ async function buildJd(opts) {
             if (d) {
                 put(d);
                 filled.push(k);
+                inheritedFromRef.push({ field: k, value: detailValueId(refByFid[String(id)]) });
             }
         }
     }
@@ -414,10 +471,17 @@ async function buildJd(opts) {
             requestLen: (requestText || '').length,
             demand: demandId ? (demandName || demandId) : '（未关联需求）',
             status: DEF_STATUS,
-            recruitFlow: (defFlow && defFlow.id) ? defFlow.name : '（未解析到默认流程）',
+            // 解析不到环境默认流程时不写该字段，表单自身默认值生效；文案按实际行为表述，避免误导。
+            recruitFlow: (defFlow && defFlow.id) ? defFlow.name : '（沿用表单默认值）',
             currentUser: currentUser ? currentUser.name : null,
             setApplied: appliedSets,
             setSkipped: skippedSets,
+            // 明示哪些字段值继承自「环境内最近一条职位记录」——这些不是用户指定的，可能来自脏数据，
+            // 必须在确认摘要里人工核对（尤其 work_location）
+            inheritedFromRef: inheritedFromRef.length ? inheritedFromRef : undefined,
+            inheritedNote: inheritedFromRef.length
+                ? '以上字段未指定，值继承自环境内最近一条职位记录，可能含历史脏数据（如重复地点），请核对后再提交'
+                : undefined,
             requiredDefaultsFilled,
         },
     };
@@ -456,19 +520,44 @@ async function prepare(args, env) {
         demandName: args.demandName ? String(args.demandName) : undefined,
         sets: setsOf(args),
     });
-    const refs = await fetchRecentReferences(ctx, jd, String(args.referenceKeyword || positionName))
-        .catch((e) => ({ available: false, reason: e.message, items: [] }));
+    // 参考检索默认关闭：环境职位数据重复严重（实测 836 条中「舟山民宿管家」30 条）且列表层
+    // 无薪资/学历字段，参考价值低于请求成本。需要时显式传 referenceKeyword 才执行；
+    // 岗位范式改由 references/position-templates.md 提供（零请求）。
+    const refs = args.referenceKeyword
+        ? await fetchRecentReferences(ctx, jd, String(args.referenceKeyword))
+            .catch((e) => ({ available: false, reason: e.message, items: [] }))
+        : {
+            available: false,
+            skipped: true,
+            reason: '未显式指定 referenceKeyword，已跳过同类职位参考检索（改用 references/position-templates.md 的岗位模板）',
+            items: [],
+        };
+    // fingerprint 必须基于完整 dataDetails（apply 阶段比对同一口径），回执里才做瘦身。
     const willSubmit = { formId: jd.formId, objId: jd.objId, dataDetails: jd.dataDetails };
     const fp = fingerprint(willSubmit);
     const continuation = await env.continuation.issue({ operation: 'recruit-stage.jd.create.apply', fingerprint: fp });
+    // 回执瘦身：willSubmit 只输出字段名清单（不含内部 fieldId），continuation 提到首部——
+    // 避免大输出被截断导致 Agent 取不到 continuation 而重复调用 prepare（实测多花 10.7s）。
+    const invFieldKeys = {};
+    for (const [k, v] of Object.entries(ctx.cache.fields[jd.objId] || {}))
+        invFieldKeys[String(v)] = k;
     return rsSuccess('recruit-stage.jd.create.prepare', {
         mode: 'prepare',
+        continuation,
+        fingerprint: fp,
         ...jd.summary,
         recentReferences: refs.items,
-        recentReferencesNote: refs.available
-            ? `已按「${refs.keyword}」在当前环境职位列表中检索（扫描 ${refs.scanned} 条，命中 ${refs.items.length} 条）——请对标这些同类职位的薪酬/人数/要求给出推荐值，一并放进确认摘要，不要逐字段询问用户`
-            : ('参考检索不可用：' + (refs.reason || '')),
-        willSubmit,
+        recentReferencesNote: refs.skipped
+            ? refs.reason
+            : refs.available
+                ? `已按「${refs.keyword}」在当前环境职位列表中检索（扫描 ${refs.scanned} 条，命中 ${refs.items.length} 条）——请对标这些同类职位的薪酬/人数/要求给出推荐值，一并放进确认摘要，不要逐字段询问用户`
+                : ('参考检索不可用：' + (refs.reason || '')),
+        willSubmit: {
+            formId: willSubmit.formId,
+            objId: willSubmit.objId,
+            fieldCount: willSubmit.dataDetails.length,
+            fields: willSubmit.dataDetails.map((d) => invFieldKeys[String(d.formField && d.formField.id)] || String(d.formField && d.formField.id)),
+        },
     }, {
         continuation,
         fingerprint: fp,

package/dist/shortcuts/recruit-stage/operations/resume-import.js

@@ -223,10 +223,14 @@ function buildSubDetails(structured, subs, cache) {
                     const parts = Array.isArray(v) ? v : String(v).split(/[,~]/);
                     const s = String(parts[0] || '').trim();
                     const e = String(parts[1] || '').trim();
-                    if (!s || !e)
+                    // 「至今」的岗位/项目只有开始日期（实测 2026-11-05：原逻辑一旦缺 end 就整行跳过，
+                    // 导致在职经历的起始日期丢失）。有哪个写哪个，两者都空才跳过。
+                    if (s)
+                        row[col.startKey] = s;
+                    if (e)
+                        row[col.endKey] = e;
+                    if (!s && !e)
                         continue;
-                    row[col.startKey] = s;
-                    row[col.endKey] = e;
                     continue;
                 }
                 const scalar = typeof v === 'object' ? String(v.optionId ?? v.content ?? '') : String(v);
@@ -632,6 +636,140 @@ function normalizeTextStructured(cache, s, warnings) {
     fixRows(s.languageAbilities, ['mastery', 'ls_ability', 'literacy']);
     return s;
 }
+// ── 日期格式预检与归一（prepare 阶段前置，避免格式引发连锁失败）──
+// 实测（2026-11-05）：人才表单接口只接受 yyyy-MM-dd。模型常给「2020.11」「2008-08」「2004.09-2008.07」，
+// 会让 dataset 新增整批校验失败 → 回退 form/core 建主表 → 回退补明细又被同一格式拦下 → 明细全丢却报 success，
+// 且实测多花 3.4s（5523ms vs 2105ms）。此处统一归一：
+//   · 只有年月 → 开始补 -01、结束补当月最后一天（语义约定，写入 warnings 明示）
+//   · 「至今/现在」→ 空（表示至今，不伪造结束日）
+//   · 区间统一成 "start,end"（comma 分隔，供 DateRange 拆两键）
+//   · 无法识别 → 跳过该字段并告警（宁缺勿整批失败），绝不静默改写
+const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+const ONGOING_RE = /至今|现在|今|now|present/i;
+const RE_RANGE_FULL = /^\s*(\d{4}[.\-/年]\d{1,2}[.\-/月]\d{1,2}\s*日?)\s*[-–—~至,，]\s*(\d{4}[.\-/年]\d{1,2}[.\-/月]\d{1,2}\s*日?|至今|现在|今)\s*$/;
+const RE_RANGE_YM = /^\s*(\d{4}[.\-/年]\d{1,2})\s*[-–—~至,，]\s*(\d{4}[.\-/年]\d{1,2}|至今|现在|今)\s*$/;
+/** 单日期片段 → yyyy-MM-dd；isEnd=true 且缺日时补该月最后一天。无法解析返回 ''。 */
+function normDatePart(raw, isEnd) {
+    const s = String(raw ?? '').trim();
+    if (!s)
+        return '';
+    if (ONGOING_RE.test(s))
+        return '';
+    if (DATE_ONLY_RE.test(s))
+        return s;
+    const m = s.match(/^(\d{4})\s*[.\-/年]?\s*(\d{1,2})?\s*[.\-/月]?\s*(\d{1,2})?\s*日?$/);
+    if (!m)
+        return '';
+    const y = Number(m[1]);
+    const mo = m[2] ? Number(m[2]) : 1;
+    if (!y || mo < 1 || mo > 12)
+        return '';
+    const lastDay = new Date(y, mo, 0).getDate();
+    let d;
+    if (m[3]) {
+        d = Number(m[3]);
+        if (d < 1 || d > lastDay)
+            return '';
+    }
+    else {
+        d = isEnd ? lastDay : 1;
+    }
+    return y + '-' + String(mo).padStart(2, '0') + '-' + String(d).padStart(2, '0');
+}
+/** 日期区间 → "start,end"；只有单值时返回单值。 */
+function normDateRange(raw) {
+    const s = Array.isArray(raw)
+        ? raw.map((x) => String(x ?? '').trim()).filter(Boolean).join(',')
+        : String(raw ?? '').trim();
+    if (!s)
+        return '';
+    const m = s.match(RE_RANGE_FULL) || s.match(RE_RANGE_YM);
+    if (m) {
+        const a = normDatePart(m[1], false);
+        if (!a)
+            return '';
+        const b = normDatePart(m[2], true);
+        return b ? a + ',' + b : a;
+    }
+    return normDatePart(s, false);
+}
+/** 就地归一结构化简历里的全部日期字段，把每处改动写进 warnings（不静默改写）。 */
+function normalizeDates(s, warnings) {
+    if (!s || typeof s !== 'object')
+        return;
+    const one = (label, val, isEnd = false) => {
+        const before = String(val ?? '').trim();
+        if (!before)
+            return '';
+        if (ONGOING_RE.test(before))
+            return '';
+        const after = normDatePart(before, isEnd);
+        if (!after) {
+            warnings.push('日期无法识别，已跳过该字段（避免接口整批校验失败）：' + label + ' = 「' + before + '」');
+            return '';
+        }
+        if (after !== before)
+            warnings.push('日期已规范化：' + label + ' 「' + before + '」→「' + after + '」');
+        return after;
+    };
+    // 主表单值日期
+    for (const k of ['joinworkdate', 'graduate_date', 'birthday']) {
+        if (s[k] === undefined || s[k] === null)
+            continue;
+        s[k] = one(k, s[k], false);
+    }
+    // 教育经历：区间（一个组件 = 起止两个物理字段，必须 comma 分隔）
+    if (Array.isArray(s.academicInformations)) {
+        for (let i = 0; i < s.academicInformations.length; i++) {
+            const r = s.academicInformations[i];
+            if (!r || typeof r !== 'object' || r.study_date === undefined)
+                continue;
+            const before = String(r.study_date ?? '').trim();
+            if (!before)
+                continue;
+            const after = normDateRange(before);
+            if (!after) {
+                warnings.push('日期区间无法识别，已跳过（避免接口整批校验失败）：academicInformations[' + i + '].study_date = 「' + before + '」');
+                r.study_date = '';
+            }
+            else {
+                if (after !== before)
+                    warnings.push('日期已规范化：academicInformations[' + i + '].study_date 「' + before + '」→「' + after + '」');
+                r.study_date = after;
+            }
+        }
+    }
+    // 工作/项目经历：起止为两个独立字段，需分别归一后由 buildSubDetails 拼成区间
+    for (const key of ['jobInformations', 'workExperiences', 'projectExperiences']) {
+        const arr = s[key];
+        if (!Array.isArray(arr))
+            continue;
+        for (let i = 0; i < arr.length; i++) {
+            const r = arr[i];
+            if (!r || typeof r !== 'object')
+                continue;
+            if (r.start_date !== undefined && r.start_date !== null) {
+                r.start_date = one(key + '[' + i + '].start_date', r.start_date, false);
+            }
+            if (r.end_date !== undefined && r.end_date !== null) {
+                r.end_date = one(key + '[' + i + '].end_date', r.end_date, true);
+            }
+        }
+    }
+    // 实习入职时间 / 获奖日期：单值日期
+    for (const [key, field] of [['internshipExperiences', 'entry_time'], ['awardExperiences', 'award_date']]) {
+        const arr = s[key];
+        if (!Array.isArray(arr))
+            continue;
+        for (let i = 0; i < arr.length; i++) {
+            const r = arr[i];
+            if (!r || typeof r !== 'object')
+                continue;
+            if (r[field] !== undefined && r[field] !== null)
+                r[field] = one(key + '[' + i + '].' + field, r[field], false);
+        }
+    }
+}
 // 读回校验：统计各子表实际落库行数（不能只看写入接口返回，必须回读）
 async function verifySubRows(ctx, formId, objId, dataId) {
     const L = await getFormLayoutMeta(ctx.host, formId);
@@ -670,7 +808,9 @@ async function loadStructured(ctx, args) {
         if (!String(s.telephone || '').trim() && !String(s.candidateName || '').trim()) {
             throw rsValidationError('structured_invalid', '结构化简历缺少 telephone 与 candidateName（至少要有手机号或姓名，否则无法查重建档）');
         }
-        return { structured: normalizeTextStructured(ctx.cache, s, warnings), textMode: true, warnings };
+        const normalizedInline = normalizeTextStructured(ctx.cache, s, warnings);
+        normalizeDates(normalizedInline, warnings);
+        return { structured: normalizedInline, textMode: true, warnings };
     }
     if (args.structuredFile) {
         const p = path.resolve(String(args.structuredFile));
@@ -680,7 +820,9 @@ async function loadStructured(ctx, args) {
         if (!String(s.telephone || '').trim() && !String(s.candidateName || '').trim()) {
             throw rsValidationError('structured_invalid', '结构化简历缺少 telephone 与 candidateName');
         }
-        return { structured: normalizeTextStructured(ctx.cache, s, warnings), textMode: true, warnings };
+        const normalizedFile = normalizeTextStructured(ctx.cache, s, warnings);
+        normalizeDates(normalizedFile, warnings);
+        return { structured: normalizedFile, textMode: true, warnings };
     }
     return { structured: null, textMode: false, warnings };
 }
@@ -1053,9 +1195,10 @@ async function apply(args, env) {
             verifyWarnings = checkAfter(after);
         }
         return rsSuccess('recruit-stage.resume.import.apply', {
-            mode: 'update', result: 'success',
+            // 更新模式同理：明细行/格数对不上时只能报 partial，不能因主表写入成功就报 success
+            mode: 'update', result: verifyWarnings.length ? 'partial' : 'success',
+            detailsState: verifyWarnings.length ? 'missing' : 'complete',
             talentId: updateTalentId,
-            applied: verifyWarnings, // placeholder replaced below
             afterSummary: { mainFieldCount: Object.keys(after.main).length, subRows: after.subRows, subCells: after.subCells },
             verifyWarnings: verifyWarnings.length ? verifyWarnings : undefined,
             talentCardUrl: resolveTalentCardUrl(ctx, updateTalentId),
@@ -1129,8 +1272,20 @@ async function apply(args, env) {
         addEntityTags(host, talentId, built.tagNames).then((v) => ({ ok: true, v }), (e) => ({ ok: false, e })),
     ]);
     const subTableVerify = verifyRes.ok ? verifyRes.v : { error: verifyRes.e?.message };
-    if (subTableVerify && subTableVerify.rowTotal === 0 && built.subRowTotal > 0) {
-        writeWarnings.push('明细行未落库（期望 ' + built.subRowTotal + ' 行，读回 0 行）');
+    // 明细完整性判定：主表建成 ≠ 建档成功。实测（2026-11-05）出现过主表 19 字段写入成功、
+    // 18 行明细 0 行落库，而返回仍是 result=success —— 只看 writeWarnings 才会发现问题。
+    // 规则：期望行数 > 0 时读回行数必须 >= 期望，否则 result 只能报 partial；回读失败则标 unverified。
+    let detailsState = 'complete';
+    if (!verifyRes.ok) {
+        detailsState = 'unverified';
+        writeWarnings.push('明细读回校验失败（无法确认明细是否落库）：' + (verifyRes.e?.message || ''));
+    }
+    else if (built.subRowTotal > 0) {
+        const gotRows = Number(subTableVerify?.rowTotal || 0);
+        if (gotRows < built.subRowTotal) {
+            detailsState = 'missing';
+            writeWarnings.push('明细行未完整落库（期望 ' + built.subRowTotal + ' 行，读回 ' + gotRows + ' 行）：主表已写入，请按 writeWarnings 修正后走 updateTalentId 补明细');
+        }
     }
     const saveEsbActions = esbRes.ok ? esbRes.v : { error: esbRes.e?.message };
     const labelMatch = labelRes.ok ? labelRes.v : 'ERR:' + (labelRes.e?.message || '');
@@ -1142,7 +1297,8 @@ async function apply(args, env) {
     const talentCardUrl = resolveTalentCardUrl(ctx, talentId);
     const talentListLocateUrl = resolveTalentListLocateUrl(ctx, talentId);
     return rsSuccess('recruit-stage.resume.import.apply', {
-        mode: 'apply', result: 'success',
+        mode: 'apply', result: detailsState === 'complete' ? 'success' : 'partial',
+        detailsState,
         newCandidateFormDataId: newId,
         talentId,
         writeChannel,

package/dist/shortcuts/workflow/continuation.js

@@ -1,10 +1,11 @@
+import { CONTINUATION_TTL_MS } from '../../core/continuation-ttl.js';
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { chmod, mkdir, readFile, readdir, unlink, writeFile } from 'node:fs/promises';
 import { homedir, hostname } from 'node:os';
 import { resolve } from 'node:path';
 import { workflowAlreadyAppliedError, workflowPartialError, workflowValidationError, } from './errors.js';
-const DEFAULT_TTL_MS = 10 * 60_000;
+const DEFAULT_TTL_MS = CONTINUATION_TTL_MS;
 /**
  * 「上一次只抢到句柄、还没发出写入」的**安全重占宽限期**。
  *