weaver-work-cli 0.1.31 → 0.1.33

package/dist/chunks/{ehr-MMYN36VA.js → ehr-WFOC3B4D.js}

@@ -4,11 +4,11 @@ import {
   E10ApiError,
   createE10RequestRuntime,
   requireE10Session
-} from "./chunk-H3WDBYJW.js";
+} from "./chunk-6ATGWRZM.js";
 import {
   E10_SESSION_EXPIRED_MESSAGE,
   getActiveProfile
-} from "./chunk-324YPTC2.js";
+} from "./chunk-D223PTXU.js";
 import {
   CliError,
   isCliError,
@@ -17,7 +17,7 @@ import {
 import "./chunk-BUSC6UAE.js";
 
 // src/shortcuts/ehr/index.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 
 // src/shortcuts/ehr/continuation.ts
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
@@ -221,7 +221,7 @@ function mapRuntimeNetworkError(error) {
 function createEhrHost(ctx, dependencies = {}) {
   let e10Session = null;
   let sessionContext = null;
-  const requireSession = dependencies.requireSession || requireE10Session;
+  const requireSession = dependencies.requireSession || ((innerCtx) => requireE10Session(innerCtx, { skipProfileEnrichment: true }));
   async function ensureSession() {
     if (!e10Session) {
       e10Session = await requireSession(ctx);
@@ -2876,8 +2876,24 @@ async function fetchListRows(host, objId, listId, body) {
   const hasDisplay = Array.isArray(displayRows) && displayRows.length > 0;
   const rows = hasDisplay ? displayRows : rawRows;
   const countData = countResponse ? normalizePaged(countResponse).data : null;
-  const total = countData?.total !== void 0 ? countData.total : rows.length;
-  return { rows, displayRows: hasDisplay ? displayRows : null, total };
+  const pageSize = typeof body.pageSize === "number" ? body.pageSize : typeof body.pageSize === "string" ? Number(body.pageSize) || rows.length : rows.length;
+  const countUsable = countData !== null && typeof countData.total === "number";
+  let total;
+  let totalExact;
+  let totalNote;
+  if (countUsable) {
+    total = countData.total;
+    totalExact = true;
+  } else if (rows.length < pageSize) {
+    total = rows.length;
+    totalExact = true;
+    totalNote = "\u8BA1\u6570\u63A5\u53E3\u4E0D\u53EF\u7528\uFF0C\u672C\u9875\u672A\u6EE1\uFF08\u5DF2\u5230\u672B\u9875\uFF09\uFF0C\u603B\u6570\u6309\u5DF2\u53D6\u56DE\u884C\u6570\u5F97\u51FA";
+  } else {
+    total = null;
+    totalExact = false;
+    totalNote = "\u8BA1\u6570\u63A5\u53E3\u4E0D\u53EF\u7528\u4E14\u672C\u9875\u5DF2\u6EE1\uFF0C\u603B\u6570\u4E0D\u53EF\u77E5\uFF08\u53EF\u8C03\u5927 pageSize \u53D6\u56DE\u5168\u90E8\u884C\u6570\uFF09";
+  }
+  return { rows, displayRows: hasDisplay ? displayRows : null, total, totalExact, totalNote };
 }
 var contextResolve = {
   name: "ehr.recruit.context.resolve",
@@ -2942,7 +2958,7 @@ var candidateSearch = {
       pageSize: toNumber(args.pageSize, "pageSize") ?? 10,
       conditions
     });
-    const { rows, displayRows, total } = await fetchListRows(env.host, talentObjId, talentList.listId, body);
+    const { rows, displayRows, total, totalExact, totalNote } = await fetchListRows(env.host, talentObjId, talentList.listId, body);
     let creatorNameMap = {};
     if (!displayRows) {
       const pureIds = [...new Set(rows.map((row) => row?.creator).filter(isPlainId).map((value) => String(value).trim()))];
@@ -2987,7 +3003,7 @@ var candidateSearch = {
         createTime: row?.create_time || null
       };
     });
-    return ehrSuccess("ehr.recruit.candidate.search", { total, rows: dataRows });
+    return ehrSuccess("ehr.recruit.candidate.search", { total, totalExact, ...totalNote ? { totalNote } : {}, rows: dataRows });
   }
 };
 var candidateList = {
@@ -3032,7 +3048,7 @@ var candidateList = {
       current: toPositiveInt(args.current, "current") ?? 1,
       pageSize: toNumber(args.pageSize, "pageSize") ?? 10
     });
-    const { rows, displayRows, total } = await fetchListRows(env.host, formObjId, listParam.listId, body);
+    const { rows, displayRows, total, totalExact, totalNote } = await fetchListRows(env.host, formObjId, listParam.listId, body);
     const outRows = rows.map((row) => {
       const cleaned = { form_data_id: row?.form_data_id || row?.id };
       for (const [key, value] of Object.entries(row || {})) {
@@ -3061,6 +3077,8 @@ var candidateList = {
     return ehrSuccess("ehr.recruit.candidate.list", {
       type,
       total,
+      totalExact,
+      ...totalNote ? { totalNote } : {},
       current: body.current,
       pageSize: body.pageSize,
       rows: outRows
@@ -3364,12 +3382,6 @@ async function resolvePersonId(host, fieldId, keyword) {
   const first = list[0];
   return first ? String(first.id || first.value || "") || null : null;
 }
-async function getInterviewPortalFieldIds(host) {
-  const response = await host.request({
-    path: "/api/recruit/candidate/getFieldIdsForInterview"
-  });
-  return response?.data || {};
-}
 async function saveFormData(host, params) {
   const layoutId = params.layoutId || params.formId;
   const customParam = {
@@ -3730,11 +3742,10 @@ async function buildInterviewPlan(env, cache, args) {
   const objId = cacheObjId(cache, "interview_plan", "\u9762\u8BD5\u8BA1\u5212\u8868\u5355");
   const formId = cacheFormId(cache, "interview_plan");
   const fields = cache.fields[objId] || {};
-  const portalFields = await getInterviewPortalFieldIds(host);
-  const fieldIdOf = (key) => fields[key] || portalFields[key] || "";
+  const fieldIdOf = (key) => fields[key] || "";
   for (const key of INTERVIEW_DATAKEYS) {
     if (!fieldIdOf(key)) {
-      throw ehrValidationError("recruit_field_missing", `\u9762\u8BD5\u8BA1\u5212\u8868\u5355\u7F3A\u5C11\u5B57\u6BB5 ${key}\uFF08ds/fields \u4E0E\u95E8\u6237\u5B57\u6BB5\u5747\u89E3\u6790\u4E0D\u5230\uFF09`);
+      throw ehrValidationError("recruit_field_missing", `\u9762\u8BD5\u8BA1\u5212\u8868\u5355\u7F3A\u5C11\u5B57\u6BB5 ${key}\uFF08\u73AF\u5883\u7F13\u5B58 ds/fields \u672A\u89E3\u6790\u5230\uFF0C\u8BF7\u91CD\u5EFA\u73AF\u5883\u7F13\u5B58\u540E\u91CD\u8BD5\uFF09`);
     }
   }
   const typeMap = await getDsOptions(host, objId, fieldIdOf("interview_type"), cache.appId);
@@ -4822,6 +4833,1146 @@ var recruitWriteOperations = [
   feedbackUrgeApply
 ];
 
+// src/shortcuts/ehr/operations/recruit-stats.ts
+var STATS_MODULES = {
+  talent: { listKey: "talent", formType: "talent_pool", title: "\u4EBA\u624D\u5E93" },
+  demand: { listKey: "demand", formType: "demand_manage", title: "\u62DB\u8058\u9700\u6C42" },
+  position: { listKey: "position", formType: "position_manage", title: "\u62DB\u8058\u804C\u4F4D" },
+  entry: { listKey: "entry", formType: "entry_manage", title: "\u5165\u804C\u7BA1\u7406" },
+  offer: { listKey: "offer", formType: "offer", title: "\u5F55\u7528\u7BA1\u7406" },
+  interview: {
+    listKey: "interview",
+    formType: "interview_plan",
+    title: "\u9762\u8BD5\u5B89\u6392",
+    note: "\u9762\u8BD5\u7BA1\u7406\u5217\u8868\u53EF\u80FD\u6309\u9875\u9762\u914D\u7F6E\u53EA\u663E\u793A\u8FD1\u671F\u8BB0\u5F55\uFF0C\u8BA1\u6570\u4EC5\u4F9B\u91CF\u7EA7\u53C2\u8003"
+  }
+};
+var DEFAULT_MODULES = ["talent", "demand", "position", "entry", "offer"];
+async function countModule(env, cache, key, pageSize, maxPages) {
+  const cfg = STATS_MODULES[key];
+  const list = cache.lists[cfg.listKey];
+  const objId = cache.forms[cfg.formType]?.objId;
+  if (!list?.listId || !objId) {
+    return {
+      key,
+      module: cfg.title,
+      available: false,
+      total: null,
+      totalExact: false,
+      scannedRows: 0,
+      note: "\u5F53\u524D\u73AF\u5883\u672A\u542F\u7528\u8BE5\u529F\u80FD\u83DC\u5355\uFF08\u672A\u627E\u5230\u5217\u8868\u6216\u8868\u5355\uFF09\uFF0C\u5DF2\u8DF3\u8FC7"
+    };
+  }
+  const baseBody = buildListBody({
+    listId: list.listId,
+    cusMenuId: list.cusMenuId,
+    menuName: list.menuName || cfg.title,
+    title: cfg.title,
+    pageSize
+  });
+  let scanned = 0;
+  let total = null;
+  let totalExact = false;
+  let note = cfg.note;
+  for (let current = 1; current <= maxPages; current++) {
+    const page = await fetchListRows(env.host, objId, list.listId, { ...baseBody, current, pageSize });
+    if (current === 1 && page.total !== null && page.totalExact) {
+      total = page.total;
+      totalExact = true;
+      break;
+    }
+    scanned += page.rows.length;
+    if (page.rows.length < pageSize) {
+      total = scanned;
+      totalExact = true;
+      break;
+    }
+  }
+  if (total === null) {
+    totalExact = false;
+    note = `\u8BA1\u6570\u63A5\u53E3\u4E0D\u53EF\u7528\u4E14\u8FBE\u626B\u63CF\u4E0A\u9650\uFF08${maxPages} \u9875 \xD7 ${pageSize} \u884C\uFF09\u4ECD\u672A\u53D6\u5B8C\uFF0C\u603B\u6570\u4E0D\u53EF\u77E5\uFF1B\u53EF\u8C03\u5927 pageSize/maxPages \u91CD\u8BD5`;
+  }
+  return { key, module: cfg.title, available: true, total, totalExact, scannedRows: scanned, ...note ? { note } : {} };
+}
+var recruitStats = {
+  name: "ehr.recruit.stats",
+  resource: "recruit",
+  method: "stats",
+  action: "ehr.recruit.stats",
+  summary: '\u62DB\u8058\u5DE5\u4F5C\u7EDF\u8BA1\uFF1A\u6309\u6A21\u5757\u7EDF\u8BA1\u8BB0\u5F55\u6570\uFF08\u4EBA\u624D\u5E93/\u62DB\u8058\u9700\u6C42/\u62DB\u8058\u804C\u4F4D/\u5165\u804C\u7BA1\u7406/\u5F55\u7528\u7BA1\u7406/\u9762\u8BD5\u5B89\u6392\uFF09\uFF0C\u8BA1\u6570\u4E0D\u53EF\u7528\u65F6\u5982\u5B9E\u6807"\u603B\u6570\u4E0D\u53EF\u77E5"',
+  capability: "recruit",
+  risk: READ,
+  inputSchema: schemaOf({
+    modules: {
+      type: "array",
+      items: { type: "string", enum: Object.keys(STATS_MODULES) },
+      uniqueItems: true,
+      description: `\u8981\u7EDF\u8BA1\u7684\u6A21\u5757\uFF0C\u9ED8\u8BA4 ${DEFAULT_MODULES.join(",")}`
+    },
+    pageSize: { type: "integer", minimum: 1, maximum: 200, description: "\u5355\u9875\u884C\u6570\uFF0C\u9ED8\u8BA4 100\uFF08\u8BA1\u6570\u63A5\u53E3\u4E0D\u53EF\u7528\u65F6\u7528\u4E8E\u5206\u9875\u5B9E\u63A2\uFF09" },
+    maxPages: { type: "integer", minimum: 1, maximum: 20, description: "\u6700\u591A\u7FFB\u9875\u6570\uFF0C\u9ED8\u8BA4 5" }
+  }),
+  handler: async (args, env) => {
+    if (!env.recruitContext) {
+      throw ehrValidationError("recruit_context_unavailable", "\u62DB\u8058\u4E0A\u4E0B\u6587\u52A0\u8F7D\u5668\u672A\u521D\u59CB\u5316");
+    }
+    const requested = args.modules === void 0 ? DEFAULT_MODULES : Array.isArray(args.modules) ? args.modules.map(String) : [];
+    if (!requested.length) {
+      throw ehrValidationError("modules_required", `modules \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4\uFF0C\u53EF\u9009\u503C\uFF1A${Object.keys(STATS_MODULES).join(" / ")}`);
+    }
+    for (const key of requested) {
+      if (!STATS_MODULES[key]) {
+        throw ehrValidationError("enum_invalid", `modules \u542B\u4E0D\u652F\u6301\u7684\u503C\uFF1A${key}\uFF08\u53EF\u9009 ${Object.keys(STATS_MODULES).join(" / ")}\uFF09`);
+      }
+    }
+    const pageSize = Number.isInteger(args.pageSize) ? Number(args.pageSize) : 100;
+    const maxPages = Number.isInteger(args.maxPages) ? Number(args.maxPages) : 5;
+    const cache = await env.recruitContext.load(env.host);
+    const modules = await Promise.all(
+      requested.map((key) => countModule(env, cache, key, pageSize, maxPages))
+    );
+    const known = modules.filter((m) => m.available && m.total !== null);
+    const unknown = modules.filter((m) => m.available && m.total === null);
+    const unavailable = modules.filter((m) => !m.available);
+    return ehrSuccess("ehr.recruit.stats", {
+      modules,
+      summary: {
+        knownTotal: known.reduce((sum, m) => sum + m.total, 0),
+        knownModules: known.map((m) => m.key),
+        unknownModules: unknown.map((m) => m.key),
+        unavailableModules: unavailable.map((m) => m.key),
+        note: unknown.length ? "\u5B58\u5728\u603B\u6570\u4E0D\u53EF\u77E5\u7684\u6A21\u5757\uFF08\u89C1\u5BF9\u5E94 note\uFF09\uFF0C\u672A\u8BA1\u5165 knownTotal" : void 0
+      }
+    }, { pageSize, maxPages });
+  }
+};
+var recruitStatsOperations = [recruitStats];
+
+// src/shortcuts/ehr/operations/recruit-position.ts
+import { createHash as createHash4 } from "node:crypto";
+var TEXT_KEYS = ["position_name"];
+var MTEXT_KEYS = ["position_duty", "work_request"];
+var PERSON_DEFAULT_KEYS = ["recr_principal", "employ_manager"];
+var REF_COPY_KEYS = [
+  "position_nature",
+  "job_category",
+  "education",
+  "work_years",
+  "work_location",
+  "salary_min",
+  "salary_max",
+  "recruit_flow"
+];
+var TEXT_DEFAULTS = { recruit_count: "1", number_of_pay_months: "12" };
+var OPTION_DEFAULTS = { salary_type: "\u6708\u85AA", recruit_type: "\u793E\u4F1A\u62DB\u8058", status: "\u62DB\u8058\u4E2D" };
+var SET_FIELDS = [
+  { arg: "education", key: "education", kind: "dict", label: "\u5B66\u5386\u8981\u6C42\uFF08\u6309\u6570\u636E\u5B57\u5178\u540D\u79F0\uFF09" },
+  { arg: "workYears", key: "work_years", kind: "dict", label: "\u5DE5\u4F5C\u5E74\u9650\uFF08\u6309\u6570\u636E\u5B57\u5178\u540D\u79F0\uFF09" },
+  { arg: "jobCategory", key: "job_category", kind: "dict", label: "\u804C\u4F4D\u7C7B\u522B\uFF08\u6309\u6570\u636E\u5B57\u5178\u540D\u79F0\uFF09" },
+  { arg: "positionNature", key: "position_nature", kind: "dict", label: "\u804C\u4F4D\u5C5E\u6027\uFF08\u6309\u6570\u636E\u5B57\u5178\u540D\u79F0\uFF09" },
+  { arg: "salaryType", key: "salary_type", kind: "option", label: "\u85AA\u916C\u7C7B\u578B\uFF08\u6708\u85AA/\u5E74\u85AA\u7B49\uFF09" },
+  { arg: "recruitType", key: "recruit_type", kind: "option", label: "\u62DB\u8058\u65B9\u5F0F\uFF08\u793E\u4F1A\u62DB\u8058/\u6821\u56ED\u62DB\u8058\u7B49\uFF09" },
+  { arg: "recruitCount", key: "recruit_count", kind: "number", label: "\u62DB\u8058\u4EBA\u6570" },
+  { arg: "salaryMin", key: "salary_min", kind: "number", label: "\u85AA\u916C\u4E0B\u9650" },
+  { arg: "salaryMax", key: "salary_max", kind: "number", label: "\u85AA\u916C\u4E0A\u9650" },
+  { arg: "numberOfPayMonths", key: "number_of_pay_months", kind: "number", label: "\u85AA\u916C\u6708\u6570" },
+  { arg: "recruitPrincipal", key: "recr_principal", kind: "person", label: "\u62DB\u8058\u8D1F\u8D23\u4EBA\uFF08\u6309\u59D3\u540D\uFF09" },
+  { arg: "employManager", key: "employ_manager", kind: "person", label: "\u7528\u4EBA\u7ECF\u7406\uFF08\u6309\u59D3\u540D\uFF09" },
+  { arg: "interviewer", key: "interviewer", kind: "person", label: "\u9762\u8BD5\u5B98\uFF08\u6309\u59D3\u540D\uFF09" },
+  { arg: "recruitHelper", key: "recr_helper", kind: "person", label: "\u62DB\u8058\u534F\u52A9\u4EBA\uFF08\u6309\u59D3\u540D\uFF09" }
+];
+var SET_SCHEMA = Object.fromEntries(
+  SET_FIELDS.map((f) => [f.arg, f.kind === "number" ? { type: "string", description: `${f.label}\uFF08\u6570\u5B57\uFF0C\u6309\u5B57\u7B26\u4E32\u4F20\uFF09` } : { type: "string", description: f.label }])
+);
+function fingerprint3(value) {
+  return createHash4("sha256").update(JSON.stringify(value ?? null)).digest("hex").slice(0, 32);
+}
+function requireConfirm3(args, action) {
+  if (args.confirm !== true) {
+    throw ehrConfirmationError(action, { hint: "\u91CD\u65B0\u8C03\u7528\u65F6\u4F20\u5165 confirm=true \u4E0E prepare \u8FD4\u56DE\u7684 continuation" });
+  }
+}
+async function requireCache(env) {
+  if (!env.recruitContext) throw ehrValidationError("recruit_context_unavailable", "\u62DB\u8058\u4E0A\u4E0B\u6587\u52A0\u8F7D\u5668\u672A\u521D\u59CB\u5316");
+  return env.recruitContext.load(env.host);
+}
+async function fetchReferenceDetails(env, cache, objId, formId) {
+  const list = cache.lists.position;
+  if (!list?.listId) return [];
+  try {
+    const body = buildListBody({
+      listId: list.listId,
+      cusMenuId: list.cusMenuId,
+      menuName: list.menuName || "\u62DB\u8058\u804C\u4F4D",
+      title: "\u62DB\u8058\u804C\u4F4D",
+      pageSize: 1
+    });
+    const page = await fetchListRows(env.host, objId, list.listId, body);
+    const row = page.rows[0];
+    const recordId = row?.form_data_id || row?.id;
+    if (!recordId) return [];
+    const record = await getFormDataRecord(env.host, formId, String(recordId), objId);
+    return toSubmitDetails(record.dataDetails);
+  } catch {
+    return [];
+  }
+}
+async function buildPositionPlan(env, cache, args) {
+  const form = cache.forms.position_manage;
+  const objId = form?.objId;
+  const formId = form?.formId || objId;
+  if (!objId || !formId) {
+    throw ehrValidationError(
+      "position_form_unavailable",
+      "\u5F53\u524D\u73AF\u5883\u672A\u542F\u7528\u300C\u62DB\u8058\u804C\u4F4D\u300D\u529F\u80FD\uFF08\u672A\u89E3\u6790\u5230 position_manage \u8868\u5355\uFF09\uFF0C\u65E0\u6CD5\u5EFA\u804C\u4F4D"
+    );
+  }
+  const fields = cache.fields[objId] || {};
+  const fid = (key) => fields[key];
+  for (const key of [...TEXT_KEYS, ...MTEXT_KEYS]) {
+    if (!fid(key)) {
+      throw ehrValidationError("recruit_field_missing", `\u804C\u4F4D\u7BA1\u7406\u7F3A\u5C11\u5B57\u6BB5 ${key}\uFF08ds/fields \u89E3\u6790\u4E0D\u5230\uFF09\uFF0C\u65E0\u6CD5\u5EFA\u804C\u4F4D`);
+    }
+  }
+  const positionName = String(args.positionName ?? "").trim();
+  if (!positionName) throw ehrValidationError("position_name_required", "positionName \u5FC5\u586B");
+  const data = /* @__PURE__ */ new Map();
+  const put = (entry) => {
+    if (entry && entry.formField?.id) data.set(String(entry.formField.id), entry);
+  };
+  const has = (key) => {
+    const id = fid(key);
+    return !!(id && data.has(String(id)));
+  };
+  put({ formField: { id: fid("position_name") }, content: positionName });
+  const duty = typeof args.duty === "string" ? args.duty : "";
+  const requirement = typeof args.requirement === "string" ? args.requirement : "";
+  if (duty && fid("position_duty")) put({ formField: { id: fid("position_duty") }, dataText: { content: duty } });
+  if (requirement && fid("work_request")) put({ formField: { id: fid("work_request") }, dataText: { content: requirement } });
+  const applied = [];
+  const skipped = [];
+  if (args.demandId !== void 0 && args.demandId !== null && args.demandId !== "") {
+    if (!fid("demand")) throw ehrValidationError("recruit_field_missing", "\u804C\u4F4D\u7BA1\u7406\u7F3A\u5C11\u5B57\u6BB5 demand\uFF0C\u65E0\u6CD5\u5173\u8054\u62DB\u8058\u9700\u6C42");
+    const demandId = String(args.demandId).replace(/[^\d]/g, "");
+    if (!demandId) throw ehrValidationError("demand_id_invalid", "demandId \u5FC5\u987B\u662F\u6570\u5B57 ID");
+    put({
+      formField: { id: fid("demand") },
+      dataOptions: [{ optionId: demandId, content: typeof args.demandName === "string" && args.demandName ? args.demandName : demandId }]
+    });
+    applied.push(`demand=${demandId}`);
+  }
+  for (const field of SET_FIELDS) {
+    const raw = args[field.arg];
+    if (raw === void 0 || raw === null || String(raw).trim() === "") continue;
+    const value = String(raw).trim();
+    const fieldId = fid(field.key);
+    if (!fieldId) {
+      skipped.push(`${field.key}\uFF08\u804C\u4F4D\u8868\u5355\u65E0\u8BE5\u5B57\u6BB5\uFF09`);
+      continue;
+    }
+    if (field.kind === "text" || field.kind === "number") {
+      put({ formField: { id: fieldId }, content: value });
+      applied.push(`${field.key}=${value}`);
+    } else if (field.kind === "option") {
+      const options = await getDsOptions(env.host, objId, fieldId, cache.appId);
+      const optionId = options[value];
+      if (!optionId) {
+        skipped.push(`${field.key}=${value}\uFF08\u9009\u9879\u672A\u5339\u914D\uFF1A${Object.keys(options).slice(0, 8).join("/")}\u2026\uFF09`);
+        continue;
+      }
+      put({ formField: { id: fieldId }, dataOptions: [{ optionId: String(optionId), content: value }] });
+      applied.push(`${field.key}=${value}`);
+    } else if (field.kind === "dict") {
+      const ids = cache.dict.by_name[value] || [];
+      const unique = [...new Set(ids.map(String))];
+      if (unique.length !== 1) {
+        skipped.push(`${field.key}=${value}\uFF08\u5B57\u5178${unique.length === 0 ? "\u65E0\u6B64\u9879" : "\u540C\u540D\u591A\u9879\uFF0C\u6B67\u4E49"}\uFF0C\u672A\u5199\u5165\uFF09`);
+        continue;
+      }
+      put({ formField: { id: fieldId }, dataOptions: [{ optionId: unique[0], content: value }] });
+      applied.push(`${field.key}=${value}`);
+    } else {
+      const personId = await resolvePersonId(env.host, fieldId, value);
+      if (!personId) {
+        skipped.push(`${field.key}=${value}\uFF08\u4EBA\u5458\u672A\u5339\u914D\uFF09`);
+        continue;
+      }
+      put({ formField: { id: fieldId }, dataOptions: [{ optionId: String(personId), content: value }] });
+      applied.push(`${field.key}=${value}`);
+    }
+  }
+  for (const [key, name] of Object.entries(OPTION_DEFAULTS)) {
+    const fieldId = fid(key);
+    if (!fieldId || has(key)) continue;
+    const options = await getDsOptions(env.host, objId, fieldId, cache.appId);
+    const optionId = options[name];
+    if (optionId) put({ formField: { id: fieldId }, dataOptions: [{ optionId: String(optionId), content: name }] });
+  }
+  for (const [key, value] of Object.entries(TEXT_DEFAULTS)) {
+    const fieldId = fid(key);
+    if (fieldId && !has(key)) put({ formField: { id: fieldId }, content: value });
+  }
+  const session = await env.host.getSession();
+  for (const key of PERSON_DEFAULT_KEYS) {
+    const fieldId = fid(key);
+    if (fieldId && !has(key) && session.userId) {
+      put({ formField: { id: fieldId }, dataOptions: [{ optionId: session.userId, content: "\u5F53\u524D\u7528\u6237" }] });
+    }
+  }
+  const refDetails = await fetchReferenceDetails(env, cache, objId, formId);
+  const refMap = /* @__PURE__ */ new Map();
+  for (const detail of refDetails) {
+    const id = detail?.formField?.id;
+    if (id) refMap.set(String(id), detail);
+  }
+  const inherited = [];
+  const missingRef = [];
+  for (const key of REF_COPY_KEYS) {
+    const fieldId = fid(key);
+    if (!fieldId || has(key)) continue;
+    const ref = refMap.get(String(fieldId));
+    if (ref) {
+      put(ref);
+      inherited.push(key);
+    } else {
+      missingRef.push(key);
+    }
+  }
+  const inverse = {};
+  for (const [dataKey, fieldId] of Object.entries(fields)) inverse[String(fieldId)] = dataKey;
+  return {
+    objId,
+    formId,
+    dataDetails: [...data.values()],
+    summary: {
+      positionName,
+      dutyLength: duty.length,
+      requirementLength: requirement.length,
+      fieldCount: data.size,
+      filledFields: [...data.keys()].map((id) => inverse[id] || id).sort(),
+      explicitApplied: applied,
+      explicitSkipped: skipped,
+      inheritedFromExistingPosition: inherited,
+      noReferenceValue: missingRef,
+      principalDefault: session.userId ? "\u5F53\u524D\u767B\u5F55\u7528\u6237" : "\u672A\u89E3\u6790\u5230\u5F53\u524D\u7528\u6237"
+    }
+  };
+}
+var positionCreatePrepare = {
+  name: "ehr.recruit.position.create.prepare",
+  resource: "recruit",
+  method: "position.create.prepare",
+  action: "ehr.recruit.position.create.prepare",
+  summary: "\u751F\u6210\u804C\u4F4D\u5E76\u5EFA\u5230\u62DB\u8058\u804C\u4F4D\u5217\u8868\u524D\u7684\u786E\u8BA4\u6458\u8981\uFF1A\u89E3\u6790\u804C\u4F4D\u8868\u5355\u5B57\u6BB5\u3001\u5957\u7528\u9ED8\u8BA4\u503C\uFF08\u72B6\u6001/\u6D41\u7A0B/\u8D1F\u8D23\u4EBA/\u5173\u8054\u5B57\u6BB5\uFF09\uFF0C\u4E0D\u5199\u5165\u4EFB\u4F55\u6570\u636E",
+  capability: "recruit",
+  risk: WRITE,
+  requiresConfirmation: true,
+  inputSchema: schemaOf(
+    {
+      positionName: { type: "string", maxLength: 120, description: "\u804C\u4F4D\u540D\u79F0\uFF08\u5FC5\u586B\uFF09" },
+      duty: { type: "string", maxLength: 2e4, description: "\u5C97\u4F4D\u804C\u8D23 / JD \u6B63\u6587\uFF08\u5199\u5165\u804C\u4F4D\u804C\u8D23\u591A\u884C\u6587\u672C\uFF09" },
+      requirement: { type: "string", maxLength: 2e4, description: "\u4EFB\u804C\u8981\u6C42\uFF08\u5199\u5165\u5DE5\u4F5C\u4EFB\u804C\u8981\u6C42\u591A\u884C\u6587\u672C\uFF09" },
+      demandId: { ...SCHEMA_ID, description: "\u5173\u8054\u62DB\u8058\u9700\u6C42 id\uFF08\u53EF\u9009\uFF09" },
+      demandName: { type: "string", maxLength: 200, description: "\u5173\u8054\u9700\u6C42\u540D\u79F0\uFF08\u4EC5\u7528\u4E8E\u6458\u8981\u5C55\u793A\uFF09" },
+      ...SET_SCHEMA
+    },
+    { required: ["positionName"] }
+  ),
+  handler: async (args, env) => {
+    const cache = await requireCache(env);
+    const plan = await buildPositionPlan(env, cache, args);
+    const session = await env.host.getSession();
+    const continuation = await env.continuation.issue(
+      {
+        operation: "ehr.recruit.position.create.apply",
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        payload: { objId: plan.objId, formId: plan.formId, positionName: String(args.positionName).trim(), dataDetails: plan.dataDetails },
+        fingerprint: fingerprint3({ objId: plan.objId, dataDetails: plan.dataDetails })
+      },
+      10 * 60 * 1e3
+    );
+    return ehrSuccess("ehr.recruit.position.create.prepare", {
+      status: "AWAITING_CONFIRMATION",
+      preview: { action: "\u751F\u6210\u804C\u4F4DJD\u5E76\u5EFA\u804C\u4F4D\uFF08saveFormData \u2192 addPosition\uFF09", ...plan.summary },
+      willSubmit: { objId: plan.objId, formId: plan.formId, dataDetails: plan.dataDetails },
+      continuation,
+      expiresInSeconds: 600
+    });
+  }
+};
+var positionCreateApply = {
+  name: "ehr.recruit.position.create.apply",
+  resource: "recruit",
+  method: "position.create.apply",
+  action: "ehr.recruit.position.create.apply",
+  summary: "\u6267\u884C\u5EFA\u804C\u4F4D\uFF08saveFormData \u2192 addPosition\uFF09\uFF1B\u5FC5\u987B\u5148 prepare \u5E76\u7ECF\u7528\u6237\u660E\u786E\u786E\u8BA4",
+  capability: "recruit",
+  risk: WRITE,
+  requiresConfirmation: true,
+  inputSchema: schemaOf(
+    {
+      positionName: { type: "string", maxLength: 120 },
+      confirm: { const: true },
+      continuation: { type: "string", minLength: 1 }
+    },
+    { required: ["positionName", "confirm", "continuation"] }
+  ),
+  handler: async (args, env) => {
+    requireConfirm3(args, "ehr.recruit.position.create.apply");
+    const lease = await env.continuation.verify(args.continuation, "ehr.recruit.position.create.apply");
+    const session = await env.host.getSession();
+    if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+      throw ehrValidationError("context_mismatch", "\u786E\u8BA4\u4E0A\u4E0B\u6587\u5DF2\u53D8\u5316\uFF08\u79DF\u6237\u6216\u767B\u5F55\u8D26\u53F7\u4E0D\u540C\uFF09\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+    }
+    const positionName = String(args.positionName ?? "").trim();
+    const payload = lease.payload || {};
+    if (payload.positionName !== positionName) {
+      throw ehrValidationError("target_changed", "\u804C\u4F4D\u540D\u79F0\u4E0E prepare \u65F6\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+    }
+    const cache = await requireCache(env);
+    const formDataId = await saveFormData(env.host, {
+      appId: cache.appId,
+      formId: String(payload.formId),
+      objId: String(payload.objId),
+      name: `\u804C\u4F4D\u7BA1\u7406-${positionName}`,
+      dataDetails: payload.dataDetails || []
+    });
+    if (!formDataId) {
+      throw ehrValidationError("save_failed", "saveFormData \u672A\u8FD4\u56DE formDataId\uFF0C\u804C\u4F4D\u672A\u521B\u5EFA");
+    }
+    const response = await env.host.request({
+      path: `/api/recruit/position/v2/addPosition?formDataId=${encodeURIComponent(formDataId)}`,
+      method: "POST",
+      operation: "ehr.recruit.position.create.apply"
+    });
+    const data = response?.data || {};
+    const positionPostId = data.positionPostId ? String(data.positionPostId) : "";
+    const created = response?.status !== false && !!positionPostId;
+    const list = cache.lists.position;
+    const baseUrl = session.baseUrl.replace(/\/+$/, "");
+    const cardUrl = `${baseUrl}/sp/ebdfpage/card/0/${payload.objId}/${formDataId}`;
+    const listLocateUrl = list?.listId ? `${baseUrl}/sp/ebdfpage/list/${list.listId}/card/0/${payload.objId}/${formDataId}/${list.listId}?id=${formDataId}&openSource=field&openSourceId=${formDataId}` : null;
+    if (!created) {
+      throw ehrValidationError(
+        "position_create_failed",
+        `\u804C\u4F4D\u8868\u5355\u5DF2\u4FDD\u5B58\uFF08formDataId=${formDataId}\uFF09\uFF0C\u4F46 addPosition \u672A\u8FD4\u56DE\u804C\u4F4D id\uFF1A${response?.msg || "\u672A\u77E5\u539F\u56E0"}\uFF1B\u8BF7\u5230\u804C\u4F4D\u7BA1\u7406\u6838\u5BF9\u540E\u518D\u51B3\u5B9A\u662F\u5426\u91CD\u8BD5`
+      );
+    }
+    return ehrSuccess("ehr.recruit.position.create.apply", {
+      result: "success",
+      formDataId,
+      positionPostId,
+      rpaChecked: data.checkRpa === void 0 ? null : !!data.checkRpa,
+      rpaValidMsg: data.rpaValidMsg || null,
+      positionName,
+      cardUrl,
+      listLocateUrl
+    });
+  }
+};
+var recruitPositionOperations = [
+  positionCreatePrepare,
+  positionCreateApply
+];
+
+// src/shortcuts/ehr/operations/recruit-candidate-import.ts
+import { createHash as createHash5 } from "node:crypto";
+import { readFile as readFile2, stat } from "node:fs/promises";
+import { basename } from "node:path";
+var SUB_TABLES = [
+  {
+    table: "rcrt_education_exp",
+    input: "academicInformations",
+    cols: {
+      school: (r) => r.school,
+      edu_major: (r) => r.edu_major ?? r.major,
+      edu_education: (r) => r.edu_education ?? r.education,
+      degree: (r) => r.degree,
+      study_date: (r) => r.study_date ?? joinRange(r.start_date, r.end_date),
+      faculty: (r) => r.faculty,
+      research_direction: (r) => r.research_direction,
+      major_courses: (r) => r.major_courses
+    }
+  },
+  {
+    table: "rcrt_work_exp",
+    input: "jobInformations",
+    cols: {
+      co_name: (r) => r.co_name ?? r.company,
+      work_position: (r) => r.work_position ?? r.position,
+      work_dept: (r) => r.work_dept ?? r.department,
+      work_desc: (r) => r.work_desc ?? r.job_description,
+      resign_cause: (r) => r.resign_cause,
+      start_end_date: (r) => r.start_end_date ?? joinRange(r.start_date, r.end_date) ?? r.work_date,
+      work_type: (r) => r.work_type
+    }
+  },
+  {
+    table: "rcrt_sxjl",
+    input: "internshipExperiences",
+    cols: {
+      sx_co_name: (r) => r.sx_co_name ?? r.company,
+      position_job: (r) => r.position_job ?? r.position,
+      job_description: (r) => r.job_description,
+      entry_time: (r) => r.entry_time,
+      sx_work_type: (r) => r.sx_work_type
+    }
+  },
+  {
+    table: "rcrt_project_exp",
+    input: "projectExperiences",
+    cols: {
+      pj_name: (r) => r.pj_name ?? r.project_name,
+      pj_role: (r) => r.pj_role,
+      pj_duty: (r) => r.pj_duty,
+      pj_introduction: (r) => r.pj_introduction ?? r.project_description,
+      pj_date: (r) => r.pj_date ?? joinRange(r.start_date, r.end_date)
+    }
+  },
+  {
+    table: "rcrt_award_exp",
+    input: "awardExperiences",
+    cols: {
+      award_name: (r) => r.award_name,
+      awarded: (r) => r.awarded,
+      credentials: (r) => r.credentials,
+      award_date: (r) => r.award_date
+    }
+  },
+  {
+    table: "rcrt_language_skill",
+    input: "languageAbilities",
+    cols: {
+      language_type: (r) => r.language_type,
+      mastery: (r) => r.mastery,
+      ls_ability: (r) => r.ls_ability,
+      literacy: (r) => r.literacy
+    }
+  }
+];
+var DICT_COLS = /* @__PURE__ */ new Set([
+  "edu_education",
+  "degree",
+  "work_type",
+  "sx_work_type",
+  "mastery",
+  "ls_ability",
+  "literacy"
+]);
+function joinRange(start, end) {
+  const s = start === void 0 || start === null ? "" : String(start).trim();
+  const e = end === void 0 || end === null ? "" : String(end).trim();
+  if (!s && !e) return void 0;
+  return `${s},${e}`;
+}
+async function resolveSubTableMeta(env, formId) {
+  let data = null;
+  try {
+    const r = await env.host.request({
+      path: `/api/ebuilder/form/form/core/getFormLayout?formId=${encodeURIComponent(formId)}`,
+      method: "GET",
+      operation: "ehr.recruit.candidate.import.prepare"
+    });
+    data = r?.data;
+  } catch {
+  }
+  if (!data) {
+    const r = await env.host.request({
+      path: "/api/ebuilder/form/form/core/getFormLayout",
+      method: "POST",
+      body: { module: "ebuilderform", formId, terminalType: "PC" },
+      operation: "ehr.recruit.candidate.import.prepare"
+    });
+    data = r?.data;
+  }
+  const comps = data?.formLayout?.pageLayouts?.[0]?.comps || [];
+  const out = {};
+  for (const comp of comps) {
+    const cfg = comp?.config || {};
+    if (comp?.type !== "DetailTable" || !cfg.dataKey || !cfg.subFormId) continue;
+    out[String(cfg.dataKey)] = {
+      dataKey: String(cfg.dataKey),
+      subFormId: String(cfg.subFormId),
+      title: String(cfg.title || ""),
+      columns: {}
+    };
+  }
+  for (const comp of comps) {
+    const cfg = comp?.config || {};
+    const subFormId = String(cfg.subFormId || "");
+    if (!subFormId || !cfg.dataKey || !cfg.fieldId) continue;
+    const target = Object.values(out).find((t) => t.subFormId === subFormId);
+    if (!target) continue;
+    const column = {
+      id: String(cfg.fieldId),
+      type: String(comp?.type || ""),
+      title: String(cfg.title || "")
+    };
+    if (cfg.start?.dataKey && cfg.end?.dataKey) {
+      column.startKey = String(cfg.start.dataKey);
+      column.endKey = String(cfg.end.dataKey);
+    }
+    target.columns[String(cfg.dataKey)] = column;
+  }
+  return out;
+}
+function makeDictResolver(cache, warnings) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const row of cache.dict?.raw || []) {
+    if (row.option_id && row.selection_name) byId.set(String(row.option_id), String(row.selection_name));
+  }
+  return (value, label) => {
+    const raw = value === void 0 || value === null ? "" : String(value).trim();
+    if (!raw) return "";
+    if (/^\d{6,}$/.test(raw)) {
+      if (byId.has(raw)) return raw;
+      warnings.push(`${label}\uFF1A\u5B57\u5178 id ${raw} \u672A\u5728\u672C\u73AF\u5883\u5B57\u5178\u4E2D\uFF0C\u5DF2\u8DF3\u8FC7`);
+      return "";
+    }
+    const ids = [...new Set((cache.dict?.by_name?.[raw] || []).map(String))];
+    if (ids.length === 1) return ids[0];
+    warnings.push(`${label}\u300C${raw}\u300D${ids.length === 0 ? "\u5728\u5B57\u5178\u4E2D\u4E0D\u5B58\u5728" : "\u547D\u4E2D\u591A\u4E2A\u540C\u540D\u9009\u9879\uFF08\u6B67\u4E49\uFF09"}\uFF0C\u5DF2\u8DF3\u8FC7`);
+    return "";
+  };
+}
+function buildSubDetails(structured, meta, nodeOfTable, resolveDict) {
+  const details = {};
+  const stats = {};
+  const nodes = {};
+  const warnings = [];
+  for (const spec of SUB_TABLES) {
+    const sub = meta[spec.table];
+    if (!sub) {
+      stats[spec.table] = 0;
+      continue;
+    }
+    const rows = Array.isArray(structured[spec.input]) ? structured[spec.input] : [];
+    const built = [];
+    for (const row of rows) {
+      if (!row || typeof row !== "object") continue;
+      const out = {};
+      for (const [colKey, pick] of Object.entries(spec.cols)) {
+        const column = sub.columns[colKey];
+        if (!column) continue;
+        let value = pick(row);
+        if (value === void 0 || value === null || String(value).trim() === "") continue;
+        if (DICT_COLS.has(colKey)) {
+          value = resolveDict(value, `${sub.title}.${column.title || colKey}`);
+          if (!value) continue;
+        }
+        if (column.startKey && column.endKey) {
+          const parts = Array.isArray(value) ? value : String(value).split(/[,~]/);
+          const start = String(parts[0] ?? "").trim();
+          const end = String(parts[1] ?? "").trim();
+          if (!start || !end) continue;
+          out[column.startKey] = start;
+          out[column.endKey] = end;
+          continue;
+        }
+        out[colKey] = String(value);
+      }
+      if (Object.keys(out).length > 0) built.push(out);
+    }
+    if (built.length === 0) {
+      stats[spec.table] = 0;
+      continue;
+    }
+    const node = nodeOfTable[sub.subFormId];
+    if (!node) {
+      warnings.push(`\u5B50\u8868\u300C${sub.title || spec.table}\u300D\u5728 getTableMapping \u4E2D\u65E0\u5BF9\u5E94\u8282\u70B9\uFF0C\u672C\u6B21\u4E0D\u5199\u5165\uFF08${built.length} \u884C\uFF09`);
+      stats[spec.table] = 0;
+      continue;
+    }
+    details[node] = built;
+    nodes[spec.table] = node;
+    stats[spec.table] = built.length;
+  }
+  return { details, stats, nodes, warnings };
+}
+async function datasetSaveFormData(env, objId, mainTable, details) {
+  const record = { mainTable };
+  for (const [node, rows] of Object.entries(details)) {
+    if (rows.length) record[node] = rows;
+  }
+  const response = await env.host.request({
+    path: "/api/ebuilder/form/dataset/v2/saveFormData",
+    method: "POST",
+    body: {
+      datajson: {
+        datas: [record],
+        header: { objId },
+        operationinfo: { fieldNoFindIgnore: "true", doAction: "false" }
+      }
+    },
+    operation: "ehr.recruit.candidate.import.apply"
+  });
+  const datajson = response?.data?.datajson || {};
+  const code = response?.message?.code;
+  const ok = (code === void 0 || String(code) === "0") && datajson.status !== false;
+  if (!ok) {
+    throw ehrValidationError(
+      "save_failed",
+      `dataset saveFormData \u5931\u8D25\uFF1A${datajson.message || response?.message?.msg || JSON.stringify(response).slice(0, 200)}`
+    );
+  }
+  const ids = Array.isArray(datajson.dataIds) ? datajson.dataIds : [];
+  if (!ids.length) {
+    throw ehrValidationError("save_failed", `dataset saveFormData \u672A\u8FD4\u56DE dataIds\uFF1A${JSON.stringify(response).slice(0, 200)}`);
+  }
+  return String(ids[0]);
+}
+async function uploadResumeFile(env, filePath, fieldId, formId) {
+  let buffer;
+  let mtimeMs = Date.now();
+  try {
+    buffer = await readFile2(filePath);
+    mtimeMs = (await stat(filePath)).mtimeMs || Date.now();
+  } catch {
+    throw ehrValidationError("resume_file_unreadable", `\u65E0\u6CD5\u8BFB\u53D6\u7B80\u5386\u6587\u4EF6\uFF1A${filePath}`);
+  }
+  const name = basename(filePath);
+  const size = buffer.length;
+  const baseForm = (withFile) => {
+    const fd2 = new FormData();
+    fd2.append("compressImg", "false");
+    fd2.append("source", "form");
+    fd2.append("fieldId", fieldId);
+    fd2.append("sourceRefId", formId);
+    fd2.append("module", "ebuilderform");
+    fd2.append("authModule", "ebuilderform");
+    fd2.append("formId", formId);
+    fd2.append("refId", formId);
+    fd2.append("size", String(size));
+    fd2.append("commonText", JSON.stringify({ fieldId, formId }));
+    if (withFile) fd2.append("file", new Blob([new Uint8Array(buffer)]), name);
+    return fd2;
+  };
+  const pre = await env.host.request({
+    path: "/api/file/preUploadCheck",
+    method: "POST",
+    multipart: baseForm(true),
+    // 预上传检查必须带文件，否则服务端 500
+    headers: { ebBusinessId: formId, langType: "zh_CN", timeZoneOffset: "-480" },
+    operation: "ehr.recruit.candidate.import.apply"
+  });
+  const preUploadId = pre?.data?.preUploadId;
+  const uploadType = pre?.data?.uploadType || "common";
+  if (!preUploadId) {
+    throw ehrValidationError("resume_preupload_failed", `\u7B80\u5386\u9884\u4E0A\u4F20\u68C0\u67E5\u5931\u8D25\uFF1A${JSON.stringify(pre || {}).slice(0, 200)}`);
+  }
+  const fd = baseForm(false);
+  fd.append("name", name);
+  fd.append("MD5", createHash5("md5").update(buffer).digest("hex"));
+  fd.append("lastModified", String(Math.round(mtimeMs)));
+  fd.append("lastModifiedDate", String(Math.round(mtimeMs)));
+  fd.append("preUploadId", String(preUploadId));
+  fd.append("uploadType", String(uploadType));
+  fd.append("file", new Blob([new Uint8Array(buffer)]), name);
+  const res = await env.host.request({
+    path: "/api/file/module/upload",
+    method: "POST",
+    multipart: fd,
+    headers: { ebBusinessId: formId, langType: "zh_CN", timeZoneOffset: "-480" },
+    operation: "ehr.recruit.candidate.import.apply"
+  });
+  const fileid = res?.data?.fileid || res?.data?.uploadModuleDto?.fileObj?.fileId || res?.data?.fileObj?.fileId;
+  if (!fileid) {
+    throw ehrValidationError("resume_upload_failed", `\u7B80\u5386\u4E0A\u4F20\u672A\u8FD4\u56DE fileid\uFF1A${JSON.stringify(res || {}).slice(0, 200)}`);
+  }
+  return { fileid: String(fileid), name, size };
+}
+async function applyPlatformTags(env, talentId, tagNames) {
+  if (!tagNames.length) return { applied: [], skipped: [] };
+  const list = await env.host.request({
+    path: "/api/my/tag/query",
+    method: "POST",
+    body: { tagModules: ["ebuilderform"], current: 1, pageSize: 500 },
+    operation: "ehr.recruit.candidate.import.apply"
+  });
+  const rows = list?.data?.data || list?.data?.list || [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const name = String(row.name ?? row.tagName ?? "").trim();
+    const id = row.tagId ?? row.id;
+    if (name && id !== void 0 && !byName.has(name)) byName.set(name, { id: String(id), name });
+  }
+  const tags = [];
+  const applied = [];
+  const skipped = [];
+  for (const name of tagNames) {
+    const hit = byName.get(name);
+    if (!hit) {
+      skipped.push(name);
+      continue;
+    }
+    tags.push({ id: hit.id, name: hit.name, type: 0 });
+    applied.push(name);
+  }
+  if (tags.length) {
+    await env.host.request({
+      path: "/api/my/tag/common/batchAddEntityTag",
+      method: "POST",
+      body: { tags, batchDatas: [{ entityId: talentId, module: "ebuilderform" }] },
+      operation: "ehr.recruit.candidate.import.apply"
+    });
+  }
+  return { applied, skipped };
+}
+async function requireCache2(env) {
+  if (!env.recruitContext) throw ehrValidationError("recruit_context_unavailable", "\u62DB\u8058\u4E0A\u4E0B\u6587\u52A0\u8F7D\u5668\u672A\u521D\u59CB\u5316");
+  return env.recruitContext.load(env.host);
+}
+function str(value) {
+  if (value === void 0 || value === null) return "";
+  return String(value).trim();
+}
+async function buildImportPlan(env, cache, args) {
+  const warnings = [];
+  const talent = cache.forms.talent_pool;
+  const objId = talent?.objId;
+  const formId = talent?.formId || objId;
+  if (!objId || !formId) {
+    throw ehrValidationError("talent_form_unavailable", "\u5F53\u524D\u73AF\u5883\u672A\u542F\u7528\u300C\u4EBA\u624D\u5E93\u300D\u529F\u80FD\uFF08\u672A\u89E3\u6790\u5230 talent_pool \u8868\u5355\uFF09");
+  }
+  const fields = cache.fields[objId] || {};
+  const name = str(args.candidateName);
+  const mobile = str(args.telephone);
+  if (!name) throw ehrValidationError("candidate_name_required", "candidateName \u5FC5\u586B");
+  if (!/^\d{6,}$/.test(mobile)) throw ehrValidationError("telephone_invalid", "telephone \u5FC5\u987B\u662F 6 \u4F4D\u4EE5\u4E0A\u6570\u5B57\uFF08\u624B\u673A\u53F7\uFF09");
+  if (!fields.candidate_name || !fields.telephone) {
+    throw ehrValidationError("recruit_field_missing", "\u73AF\u5883\u7F13\u5B58\u7F3A\u4EBA\u624D\u59D3\u540D\u5B57\u6BB5(candidate_name)\u6216\u624B\u673A\u5B57\u6BB5(telephone)");
+  }
+  const resolveDict = makeDictResolver(cache, warnings);
+  const main = {};
+  const putText = (key, value, longText = false) => {
+    if (!fields[key]) return;
+    const text = str(value);
+    if (!text) return;
+    main[key] = text;
+    void longText;
+  };
+  putText("candidate_name", name);
+  putText("telephone", mobile);
+  putText("email", args.email);
+  putText("birthday", args.birthday);
+  putText("age", args.age);
+  putText("college", args.college);
+  putText("graduate_date", args.graduateDate);
+  putText("joinworkdate", args.joinworkdate);
+  putText("intend_position", args.intendPosition);
+  putText("intended_workplace", args.intendedWorkplace);
+  putText("self_desc", args.selfDesc, true);
+  putText("work_ability", args.workAbility, true);
+  for (const [key, inputKey, label] of [
+    ["gender", "genderName", "\u6027\u522B"],
+    ["highest_degree", "highestDegreeName", "\u6700\u9AD8\u5B66\u5386"]
+  ]) {
+    if (!fields[key]) continue;
+    const raw = str(args[inputKey]);
+    if (!raw) continue;
+    const id = resolveDict(raw, label);
+    if (id) main[key] = id;
+  }
+  const channel = str(args.channel);
+  if (channel) {
+    if (!fields.channel) warnings.push("\u4EBA\u624D\u8868\u5355\u65E0\u6E20\u9053\u5B57\u6BB5\uFF0Cchannel \u5DF2\u5FFD\u7565");
+    else {
+      const id = resolveDict(channel, "\u6E20\u9053");
+      if (id) main.channel = id;
+    }
+  }
+  if (fields.is_blacklist) {
+    const noId = resolveDict("\u5426", "\u9ED1\u540D\u5355");
+    if (noId) main.is_blacklist = noId;
+  }
+  let subStats = {};
+  let detailNodes = {};
+  let details = {};
+  try {
+    const mappingResponse = await env.host.request({
+      path: `/api/ebuilder/form/dataset/v1/getTableMapping?objId=${encodeURIComponent(objId)}`,
+      method: "GET",
+      operation: "ehr.recruit.candidate.import.prepare"
+    });
+    const mapping = mappingResponse?.data;
+    if (!mapping?.mainTable) throw new Error("getTableMapping \u672A\u8FD4\u56DE mainTable");
+    const nodeOfTable = {};
+    for (const [node, tableId] of Object.entries(mapping)) {
+      if (node === "mainTable") continue;
+      nodeOfTable[String(tableId)] = node;
+    }
+    const meta = await resolveSubTableMeta(env, formId);
+    const built = buildSubDetails(args, meta, nodeOfTable, resolveDict);
+    details = built.details;
+    subStats = built.stats;
+    detailNodes = built.nodes;
+    warnings.push(...built.warnings);
+  } catch (error) {
+    warnings.push(`\u660E\u7EC6\u8868\u672A\u5199\u5165\uFF1A${error?.message || "\u672A\u77E5\u9519\u8BEF"}\uFF08\u4E3B\u8868\u7167\u5E38\u5EFA\u6863\uFF09`);
+  }
+  const subRowTotal = Object.values(subStats).reduce((sum, n) => sum + n, 0);
+  const summary = {
+    candidateName: name,
+    telephone: mobile,
+    email: str(args.email) || "(\u672A\u586B)",
+    channel: channel || "(\u672A\u6307\u5B9A)",
+    mainFieldCount: Object.keys(main).length,
+    mainFields: Object.keys(main).sort(),
+    subTableRows: subStats,
+    subRowTotal,
+    detailNodes,
+    platformTags: Array.isArray(args.tags) ? args.tags : [],
+    resumeFile: str(args.resumeFile) || "(\u672A\u63D0\u4F9B\u539F\u4EF6)",
+    warnings
+  };
+  return {
+    objId,
+    formId,
+    talentObjId: objId,
+    mainTable: main,
+    details,
+    subStats,
+    detailNodes,
+    warnings,
+    talentName: name,
+    mobile,
+    summary
+  };
+}
+var candidateImportPrepare = {
+  name: "ehr.recruit.candidate.import.prepare",
+  resource: "recruit",
+  method: "candidate.import.prepare",
+  action: "ehr.recruit.candidate.import.prepare",
+  summary: "\u7B80\u5386\u5BFC\u5165\u5EFA\u4EBA\u624D\u7684\u786E\u8BA4\u6458\u8981\uFF1A\u624B\u673A\u53F7\u67E5\u91CD + \u4E3B\u8868\u5B57\u6BB5\u6620\u5C04 + 6 \u5F20\u660E\u7EC6\u8868\u884C\u6570 + \u6807\u7B7E\u6838\u9A8C\uFF0C\u4E0D\u5199\u5165\u4EFB\u4F55\u6570\u636E",
+  capability: "recruit",
+  risk: WRITE,
+  requiresConfirmation: true,
+  inputSchema: schemaOf({
+    candidateName: { type: "string", maxLength: 60, description: "\u59D3\u540D\uFF08\u5FC5\u586B\uFF09" },
+    telephone: { type: "string", pattern: "^\\d{6,20}$", description: "\u624B\u673A\u53F7\uFF08\u5FC5\u586B\uFF0C\u67E5\u91CD\u4E3B\u952E\uFF09" },
+    email: { type: "string", maxLength: 120 },
+    genderName: { type: "string", description: "\u6027\u522B\u540D\u79F0\uFF08\u5982 \u7537/\u5973\uFF0C\u6309\u672C\u73AF\u5883\u5B57\u5178\u53CD\u67E5\uFF09" },
+    birthday: { type: "string", description: "\u51FA\u751F\u65E5\u671F YYYY-MM-DD" },
+    age: { type: "string", description: "\u5E74\u9F84" },
+    highestDegreeName: { type: "string", description: "\u6700\u9AD8\u5B66\u5386\u540D\u79F0\uFF08\u5982 \u672C\u79D1/\u7855\u58EB\uFF09" },
+    college: { type: "string", maxLength: 120, description: "\u6BD5\u4E1A\u9662\u6821" },
+    graduateDate: { type: "string", description: "\u6BD5\u4E1A\u65F6\u95F4" },
+    joinworkdate: { type: "string", description: "\u53C2\u52A0\u5DE5\u4F5C\u65E5\u671F" },
+    intendPosition: { type: "string", maxLength: 120, description: "\u610F\u5411\u5C97\u4F4D" },
+    intendedWorkplace: { type: "string", maxLength: 120, description: "\u671F\u671B\u5DE5\u4F5C\u5730\u70B9" },
+    selfDesc: { type: "string", maxLength: 2e4, description: "\u81EA\u6211\u8BC4\u4EF7\uFF08\u957F\u6587\u672C\uFF09" },
+    workAbility: { type: "string", maxLength: 2e4, description: "\u804C\u4E1A\u6280\u80FD/\u6280\u672F\u6808\uFF08\u957F\u6587\u672C\uFF09" },
+    channel: { type: "string", maxLength: 60, description: "\u4EBA\u624D\u6765\u6E90\u6E20\u9053\u540D\u79F0\uFF08\u5982 \u667A\u8054\u62DB\u8058/\u5185\u63A8\uFF09" },
+    tags: { type: "array", items: { type: "string" }, maxItems: 20, description: "\u5E73\u53F0\u6807\u7B7E\u540D\u79F0\uFF08\u987B\u4E3A\u672C\u73AF\u5883\u5DF2\u6709\u6807\u7B7E\uFF0C\u540C\u540D\u4F18\u5148\u516C\u5171\uFF1B\u4E0D\u81EA\u52A8\u521B\u5EFA\uFF09" },
+    resumeFile: { type: "string", description: "\u7B80\u5386\u539F\u4EF6\u672C\u5730\u8DEF\u5F84\uFF08\u53EF\u9009\uFF1B\u63D0\u4F9B\u5219\u4E0A\u4F20\u5230\u539F\u59CB\u7B80\u5386\u9644\u4EF6\u5B57\u6BB5\uFF09" },
+    academicInformations: {
+      type: "array",
+      maxItems: 20,
+      description: "\u6559\u80B2\u7ECF\u5386\uFF08school/edu_major/edu_education/degree/study_date/faculty/research_direction/major_courses\uFF09",
+      items: { type: "object" }
+    },
+    jobInformations: {
+      type: "array",
+      maxItems: 30,
+      description: "\u5DE5\u4F5C\u7ECF\u5386\uFF08co_name/work_position/work_dept/work_desc/resign_cause/start_date/end_date/work_type\uFF09",
+      items: { type: "object" }
+    },
+    internshipExperiences: {
+      type: "array",
+      maxItems: 20,
+      description: "\u5B9E\u4E60\u7ECF\u5386\uFF08sx_co_name/position_job/job_description/entry_time/sx_work_type\uFF09",
+      items: { type: "object" }
+    },
+    projectExperiences: {
+      type: "array",
+      maxItems: 30,
+      description: "\u9879\u76EE\u7ECF\u5386\uFF08pj_name/pj_role/pj_duty/pj_introduction/start_date/end_date\uFF09",
+      items: { type: "object" }
+    },
+    awardExperiences: {
+      type: "array",
+      maxItems: 20,
+      description: "\u83B7\u5956\u7ECF\u5386\uFF08award_name/awarded/credentials/award_date\uFF09",
+      items: { type: "object" }
+    },
+    languageAbilities: {
+      type: "array",
+      maxItems: 10,
+      description: "\u8BED\u8A00\u80FD\u529B\uFF08language_type/mastery/ls_ability/literacy\uFF09",
+      items: { type: "object" }
+    }
+  }, { required: ["candidateName", "telephone"] }),
+  handler: async (args, env) => {
+    const cache = await requireCache2(env);
+    const plan = await buildImportPlan(env, cache, args);
+    const dup = await checkDuplicateByMobile(env, cache, plan.mobile);
+    if (dup.length > 1) {
+      throw ehrValidationError("duplicate_ambiguous", `\u624B\u673A\u53F7 ${plan.mobile} \u5B58\u5728\u591A\u6761\u5019\u9009\uFF08\u6570\u636E\u5F02\u5E38\uFF09\uFF0C\u8BF7\u4EBA\u5DE5\u6838\u5BF9\u540E\u518D\u51B3\u5B9A\uFF0C\u4E0D\u81EA\u52A8\u65B0\u5EFA`);
+    }
+    const dupRow = dup[0];
+    const session = await env.host.getSession();
+    const continuation = await env.continuation.issue(
+      {
+        operation: "ehr.recruit.candidate.import.apply",
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        payload: {
+          objId: plan.objId,
+          formId: plan.formId,
+          mainTable: plan.mainTable,
+          details: plan.details,
+          tags: Array.isArray(args.tags) ? args.tags.map(String) : [],
+          resumeFile: str(args.resumeFile),
+          subStats: plan.subStats,
+          warnings: plan.warnings,
+          candidateName: plan.talentName,
+          telephone: plan.mobile
+        }
+      },
+      10 * 60 * 1e3
+    );
+    return ehrSuccess("ehr.recruit.candidate.import.prepare", {
+      status: "AWAITING_CONFIRMATION",
+      preview: {
+        action: "\u7B80\u5386\u5BFC\u5165\u5EFA\u4EBA\u624D\uFF08dataset/v2/saveFormData \u4E3B\u8868+\u660E\u7EC6 \u2192 \u6279\u6B21 \u2192 \u667A\u80FD\u6807\u7B7E \u2192 \u5E73\u53F0\u6807\u7B7E\uFF09",
+        ...plan.summary,
+        duplicate: dupRow ? `\u5DF2\u5B58\u5728\u540C\u624B\u673A\u53F7\u4EBA\u624D\u300C${dupRow.candidate_name || dupRow.name || ""}\u300D\uFF08id=${dupRow.form_data_id || dupRow.id}\uFF09\u2192 apply \u5C06\u963B\u65AD` : "\u65E0\u91CD\u590D"
+      },
+      willSubmit: {
+        objId: plan.objId,
+        mainTable: plan.mainTable,
+        details: plan.details,
+        tags: Array.isArray(args.tags) ? args.tags : []
+      },
+      continuation,
+      expiresInSeconds: 600
+    });
+  }
+};
+var candidateImportApply = {
+  name: "ehr.recruit.candidate.import.apply",
+  resource: "recruit",
+  method: "candidate.import.apply",
+  action: "ehr.recruit.candidate.import.apply",
+  summary: "\u6267\u884C\u7B80\u5386\u5BFC\u5165\u5EFA\u4EBA\u624D\uFF08\u4E3B\u8868+\u660E\u7EC6 \u2192 \u6279\u6B21 \u2192 \u667A\u80FD\u6807\u7B7E \u2192 \u5E73\u53F0\u6807\u7B7E \u2192 \u53CC\u94FE\u63A5\uFF09\uFF1B\u5FC5\u987B\u5148 prepare \u5E76\u7ECF\u7528\u6237\u660E\u786E\u786E\u8BA4",
+  capability: "recruit",
+  risk: WRITE,
+  requiresConfirmation: true,
+  inputSchema: schemaOf(
+    {
+      candidateName: { type: "string", maxLength: 60 },
+      telephone: { type: "string", pattern: "^\\d{6,20}$" },
+      resumeFile: { type: "string" },
+      tags: { type: "array", items: { type: "string" }, maxItems: 20 },
+      confirm: { const: true },
+      continuation: { type: "string", minLength: 1 }
+    },
+    { required: ["candidateName", "telephone", "confirm", "continuation"] }
+  ),
+  handler: async (args, env) => {
+    if (args.confirm !== true) {
+      throw ehrConfirmationError("ehr.recruit.candidate.import.apply", {
+        hint: "\u91CD\u65B0\u8C03\u7528\u65F6\u4F20\u5165 confirm=true \u4E0E prepare \u8FD4\u56DE\u7684 continuation"
+      });
+    }
+    const lease = await env.continuation.verify(args.continuation, "ehr.recruit.candidate.import.apply");
+    const session = await env.host.getSession();
+    if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+      throw ehrValidationError("context_mismatch", "\u786E\u8BA4\u4E0A\u4E0B\u6587\u5DF2\u53D8\u5316\uFF08\u79DF\u6237\u6216\u767B\u5F55\u8D26\u53F7\u4E0D\u540C\uFF09\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+    }
+    const payload = lease.payload || {};
+    if (payload.candidateName !== str(args.candidateName) || payload.telephone !== str(args.telephone)) {
+      throw ehrValidationError("target_changed", "\u59D3\u540D\u6216\u624B\u673A\u53F7\u4E0E prepare \u65F6\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+    }
+    const cache = await requireCache2(env);
+    const objId = String(payload.objId);
+    const formId = String(payload.formId);
+    const fields = cache.fields[objId] || {};
+    const mainTable = { ...payload.mainTable || {} };
+    const resumeFieldKey = "original_resume";
+    const resumeFile = str(payload.resumeFile);
+    let uploaded = null;
+    if (resumeFile) {
+      if (!fields[resumeFieldKey]) {
+        throw ehrValidationError("resume_field_missing", "\u4EBA\u624D\u8868\u5355\u65E0\u300C\u539F\u59CB\u7B80\u5386\u300D\u9644\u4EF6\u5B57\u6BB5\uFF08original_resume\uFF09\uFF0C\u65E0\u6CD5\u4E0A\u4F20\u539F\u4EF6");
+      }
+      uploaded = await uploadResumeFile(env, resumeFile, fields[resumeFieldKey], formId);
+      mainTable[resumeFieldKey] = uploaded.fileid;
+    }
+    let talentId;
+    try {
+      talentId = await datasetSaveFormData(env, objId, mainTable, payload.details || {});
+    } catch (error) {
+      if (error?.subtype === "save_failed") throw error;
+      throw ehrPartialError(
+        `\u7B80\u5386\u5EFA\u6863\u5199\u5165\u7ED3\u679C\u4E0D\u786E\u5B9A\uFF08${error?.message || "\u672A\u77E5\u9519\u8BEF"}\uFF09\uFF1A\u8BF7\u5148\u7528\u4EBA\u624D\u5E93\u641C\u7D22\u624B\u673A\u53F7 ${payload.telephone} \u6838\u5BF9\u662F\u5426\u5DF2\u5EFA\u6863\uFF0C\u7981\u6B62\u76F4\u63A5\u91CD\u8BD5`,
+        { candidateName: payload.candidateName, telephone: payload.telephone }
+      );
+    }
+    let batchOk = null;
+    let batchNote;
+    try {
+      await env.host.request({
+        path: `/api/recruit/candidate/initTalentBatch?formDataId=${encodeURIComponent(talentId)}`,
+        method: "POST",
+        operation: "ehr.recruit.candidate.import.apply"
+      });
+      batchOk = true;
+    } catch (error) {
+      batchOk = false;
+      batchNote = `\u4EBA\u624D\u5DF2\u5EFA\u6863\uFF0C\u4F46\u521D\u59CB\u5316\u4EBA\u624D\u6279\u6B21\u5931\u8D25\uFF1A${error?.message || "\u672A\u77E5\u9519\u8BEF"}\uFF08\u53EF\u5728\u4EBA\u624D\u5361\u7247\u624B\u52A8\u5904\u7406\uFF09`;
+    }
+    let labelMatch = null;
+    try {
+      const r = await env.host.request({
+        path: `/api/recruit/label/matchTalentLabel?talentId=${encodeURIComponent(talentId)}`,
+        method: "POST",
+        body: {},
+        operation: "ehr.recruit.candidate.import.apply"
+      });
+      labelMatch = r?.data === void 0 ? "TRIGGERED" : String(r.data);
+    } catch {
+      labelMatch = "FAILED\uFF08\u4E0D\u5F71\u54CD\u5EFA\u6863\uFF0C\u53EF\u7A0D\u540E\u5728\u4EBA\u624D\u5361\u7247\u624B\u52A8\u89E6\u53D1\uFF09";
+    }
+    let tagResult = { applied: [], skipped: [] };
+    try {
+      tagResult = await applyPlatformTags(env, talentId, Array.isArray(payload.tags) ? payload.tags.map(String) : []);
+    } catch (error) {
+      tagResult = { applied: [], skipped: Array.isArray(payload.tags) ? payload.tags.map(String) : [] };
+    }
+    const baseUrl = session.baseUrl.replace(/\/+$/, "");
+    const extra = String(cache.selfUse) === "1" ? "&recruitType=useSelf" : "";
+    const talentCardUrl = cache.ebdDetailPageId ? `${baseUrl}/sp/ebdpage/view/${cache.ebdDetailPageId}?talentId=${talentId}${extra}` : null;
+    const talentListId = cache.lists.talent?.listId;
+    const talentListLocateUrl = talentListId ? `${baseUrl}/sp/ebdfpage/list/${talentListId}?talentId=${talentId}${extra}` : null;
+    const warnings = [...payload.warnings || []];
+    if (batchNote) warnings.push(batchNote);
+    return ehrSuccess("ehr.recruit.candidate.import.apply", {
+      result: "success",
+      talentId,
+      candidateName: payload.candidateName,
+      telephone: payload.telephone,
+      mainTableFields: Object.keys(mainTable).length,
+      detailRows: payload.subStats || void 0,
+      attachment: uploaded ? { name: uploaded.name, size: uploaded.size } : null,
+      batch: { ok: batchOk, note: batchNote },
+      labelMatch,
+      tagsApplied: tagResult.applied,
+      tagsSkipped: tagResult.skipped,
+      talentCardUrl,
+      talentListLocateUrl
+    }, warnings.length ? { warnings } : void 0);
+  }
+};
+var recruitCandidateImportOperations = [
+  candidateImportPrepare,
+  candidateImportApply
+];
+
 // src/shortcuts/ehr/operations/salary.ts
 function requireMonthRange(value, field) {
   if (!Array.isArray(value) || value.length === 0) {
@@ -5003,7 +6154,10 @@ function buildRegistry() {
     ...hrDataSourceOperations,
     ...hrReportOperations,
     ...recruitOperations,
-    ...recruitWriteOperations
+    ...recruitWriteOperations,
+    ...recruitStatsOperations,
+    ...recruitPositionOperations,
+    ...recruitCandidateImportOperations
   ];
   for (const definition of definitions) {
     if (registry.has(definition.name)) {
@@ -5114,7 +6268,7 @@ async function inputFrom(options, extra = {}) {
   if (opts.input) {
     let raw;
     try {
-      raw = stripBom(opts.input === "-" ? await readStdin() : await readFile2(String(opts.input), "utf8"));
+      raw = stripBom(opts.input === "-" ? await readStdin() : await readFile3(String(opts.input), "utf8"));
     } catch {
       throw ehrValidationError("input_unreadable", `\u65E0\u6CD5\u8BFB\u53D6 --input\uFF1A${String(opts.input)}`);
     }