@alipay/alipay-aipay 1.8.2 → 1.8.4

package/skill/references/normal/scripts/onboarding_message_runner.mjs

@@ -244,13 +244,6 @@ function assertMccQuery(query) {
 }
 
 const mccSelectionReceiptPrefix = 'AIPAY_MCC_SELECTION_V1.';
-const ignoredMccQueryTokens = new Set([
-  '服务', '企业', '个人', '提供', '适用', '用于', '平台', '项目', '申请', '商家', '公司',
-  '互联', '联网', '互联网', '在线', '用品', '收费', '缴费', '费用', '适用于', '经营',
-  '业务', '相关', '主体', '从事', '网站', '网页', '购买', '买票', '购票', '票务', '售票',
-  '预约', '预定', '退票', '支付', '付款', '收款', '下单', '订单', '交易', '销售', '售卖',
-  '商品', '产品'
-]);
 
 function activeMccRunId(env = process.env) {
   const candidate = env.ALIPAY_AIPAY_RUN_ID
@@ -378,8 +371,10 @@ function mccCatalogForAgent(records) {
 }
 
 function parseAgentCandidateRefs(args, records) {
-  const raw = optional(args, 'agent-candidate-refs-json');
-  if (raw === undefined) return { codes: [] };
+  if (!Object.prototype.hasOwnProperty.call(args, 'agent-candidate-refs-json')) {
+    return { provided: false, codes: [] };
+  }
+  const raw = args['agent-candidate-refs-json'];
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -397,7 +392,7 @@ function parseAgentCandidateRefs(args, records) {
     }
     codes.push(refs.get(ref));
   }
-  return { codes };
+  return { provided: true, codes };
 }
 
 function mccTableSummary(records) {
@@ -435,190 +430,12 @@ function directMccCode(query, records) {
   return { isCode: true, matches: [...records.keys()].filter((code) => code.endsWith(`_${raw}`)) };
 }
 
-function mccNgrams(value, size) {
-  const grams = new Set();
-  const searchableText = meaningfulMccSearch(value);
-  for (const segment of searchableText.split(/\s+/u).filter(Boolean)) {
-    const characters = [...segment];
-    for (let index = 0; index <= characters.length - size; index += 1) {
-      const gram = characters.slice(index, index + size).join('');
-      if (/^[\p{L}\p{N}]+$/u.test(gram)) grams.add(gram);
-    }
-  }
-  return grams;
-}
-
-function meaningfulMccSearch(value) {
-  let searchableText = normalizeSearch(value);
-  const ignoredTerms = [...ignoredMccQueryTokens]
-    .sort((left, right) => [...right].length - [...left].length);
-  for (const term of ignoredTerms) searchableText = searchableText.replaceAll(term, ' ');
-  return searchableText
-    .trim()
-    .replace(/\s+/gu, ' ')
-    .split(' ')
-    .filter((segment) => [...segment].length >= 2)
-    .join(' ');
-}
-
-function parseMccSemanticTerms(args) {
-  const raw = optional(args, 'semantic-terms-json');
-  if (raw === undefined) return [];
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error('semantic-terms-json 必须是合法 JSON 字符串数组');
-  }
-  if (!Array.isArray(parsed) || parsed.length > 12 || parsed.some((term) => typeof term !== 'string')) {
-    throw new Error('semantic-terms-json 必须是最多 12 项的 JSON 字符串数组');
-  }
-  const normalized = [];
-  let totalLength = 0;
-  for (const rawTerm of parsed) {
-    if (/\u0000|[\u0001-\u001f\u007f]/u.test(rawTerm)) {
-      throw new Error('semantic-terms-json 包含控制字符');
-    }
-    const term = normalizeSearch(rawTerm);
-    const termLength = [...term.replace(/\s+/gu, '')].length;
-    if (termLength < 2 || termLength > 40) {
-      throw new Error('semantic-terms-json 每项长度必须为 2 到 40 个字符');
-    }
-    if (/(?:A\d{4}\s*)?B\d{4}/iu.test(term)) {
-      throw new Error('semantic-terms-json 只能包含业务概念词，禁止提供 MCC 编码');
-    }
-    totalLength += termLength;
-    if (!normalized.includes(term)) normalized.push(term);
-  }
-  if (totalLength > 240) throw new Error('semantic-terms-json 总长度不得超过 240 个字符');
-  return normalized.sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
-}
-
-function mccDocumentFrequency(indexedRecords) {
-  const frequencies = new Map();
-  for (const indexed of indexedRecords) {
-    const documentGrams = new Set([
-      ...indexed.nameBigrams,
-      ...indexed.nameTrigrams,
-      ...indexed.businessBigrams,
-      ...indexed.businessTrigrams
-    ]);
-    for (const gram of documentGrams) frequencies.set(gram, (frequencies.get(gram) || 0) + 1);
-  }
-  return frequencies;
-}
-
-function weightedMccOverlap(queryGrams, documentGrams, frequencies, recordCount, size) {
-  let weight = 0;
-  for (const gram of queryGrams) {
-    if (!documentGrams.has(gram)) continue;
-    const documentCount = frequencies.get(gram) || 0;
-    weight += (Math.log((recordCount + 1) / (documentCount + 1)) + 1) * (size === 3 ? 1.6 : 1);
-  }
-  return weight;
-}
-
-function mccPhraseCoverage(haystackSegments, needleSegments) {
-  let coverage = 0;
-  for (const needle of needleSegments) {
-    if (ignoredMccQueryTokens.has(needle)) continue;
-    const needleLength = [...needle].length;
-    for (const haystack of haystackSegments) {
-      if (!haystack.includes(needle)) continue;
-      coverage = Math.max(coverage, needleLength / [...haystack].length);
-    }
-  }
-  return coverage;
-}
-
-function mccTextEvidence(value, indexed, frequencies, recordCount) {
-  const normalizedValue = normalizeSearch(value);
-  const valueSegments = meaningfulMccSearch(normalizedValue).split(' ').filter(Boolean);
-  const valueBigrams = mccNgrams(normalizedValue, 2);
-  const valueTrigrams = mccNgrams(normalizedValue, 3);
-  const exactName = indexed.name === normalizedValue
-    || (normalizedValue.split(' ').length === 1 && indexed.nameSegments.includes(normalizedValue));
-  const nameContainsValueCoverage = mccPhraseCoverage(indexed.nameEvidenceSegments, valueSegments);
-  const valueContainsNameCoverage = mccPhraseCoverage(valueSegments, indexed.nameEvidenceSegments);
-  const businessContainsValueCoverage = mccPhraseCoverage(indexed.businessEvidenceSegments, valueSegments);
-  const nameBigram = weightedMccOverlap(valueBigrams, indexed.nameBigrams, frequencies, recordCount, 2);
-  const nameTrigram = weightedMccOverlap(valueTrigrams, indexed.nameTrigrams, frequencies, recordCount, 3);
-  const businessBigram = weightedMccOverlap(valueBigrams, indexed.businessBigrams, frequencies, recordCount, 2);
-  const businessTrigram = weightedMccOverlap(valueTrigrams, indexed.businessTrigrams, frequencies, recordCount, 3);
-  const matchedBigrams = new Set([
-    ...[...valueBigrams].filter((gram) => indexed.nameBigrams.has(gram)),
-    ...[...valueBigrams].filter((gram) => indexed.businessBigrams.has(gram))
-  ]);
-  const matchedTrigrams = new Set([
-    ...[...valueTrigrams].filter((gram) => indexed.nameTrigrams.has(gram)),
-    ...[...valueTrigrams].filter((gram) => indexed.businessTrigrams.has(gram))
-  ]);
-  const rareBigramDocumentLimit = Math.max(1, Math.ceil(recordCount * 0.02));
-  const hasRareBigram = [...matchedBigrams].some((gram) => (
-    (frequencies.get(gram) || recordCount) <= rareBigramDocumentLimit
-  ));
-  const hasLexicalEvidence = matchedTrigrams.size > 0
-    || matchedBigrams.size >= 2
-    || (valueBigrams.size <= 2 && hasRareBigram);
-  const phraseEvidence = nameContainsValueCoverage > 0
-    || valueContainsNameCoverage > 0
-    || businessContainsValueCoverage > 0;
-  return {
-    eligible: exactName || phraseEvidence || hasLexicalEvidence,
-    exactName,
-    score: (exactName ? 100000 : 0)
-      + (nameContainsValueCoverage * 6000)
-      + (valueContainsNameCoverage * 3000)
-      + (businessContainsValueCoverage * 2500)
-      + ((nameBigram + nameTrigram) * 120)
-      + ((businessBigram + businessTrigram) * 40)
-  };
-}
-
-function deterministicMccMatches(query, records, { limit = 8, semanticTerms = [] } = {}) {
+function directMccName(query, records) {
   const normalizedQuery = assertMccQuery(query);
-  const indexedRecords = [...records.values()].map((record) => {
-    const name = normalizeSearch(record.name);
-    const businesses = normalizeSearch(record.applicableBusinesses);
-    return {
-      record,
-      name,
-      nameSegments: name.split(' ').filter(Boolean),
-      nameEvidenceSegments: meaningfulMccSearch(name).split(' ').filter(Boolean),
-      businessEvidenceSegments: meaningfulMccSearch(businesses).split(' ').filter(Boolean),
-      nameBigrams: mccNgrams(name, 2),
-      nameTrigrams: mccNgrams(name, 3),
-      businessBigrams: mccNgrams(businesses, 2),
-      businessTrigrams: mccNgrams(businesses, 3)
-    };
-  });
-  const frequencies = mccDocumentFrequency(indexedRecords);
-  const scored = [];
-
-  for (const indexed of indexedRecords) {
-    const originalEvidence = mccTextEvidence(normalizedQuery, indexed, frequencies, indexedRecords.length);
-    const semanticEvidence = semanticTerms
-      .map((term) => mccTextEvidence(term, indexed, frequencies, indexedRecords.length))
-      .filter((evidence) => evidence.eligible)
-      .sort((left, right) => right.score - left.score)[0];
-    if (!originalEvidence.eligible && !semanticEvidence) continue;
-    scored.push({
-      record: indexed.record,
-      score: originalEvidence.score + ((semanticEvidence?.score || 0) * 0.7),
-      exactName: originalEvidence.exactName,
-      originalEligible: originalEvidence.eligible,
-      semanticEligible: Boolean(semanticEvidence),
-      semanticExactName: Boolean(semanticEvidence?.exactName)
-    });
-  }
-
-  const exactMatches = scored.filter(({ exactName }) => exactName);
-  const ranked = exactMatches.length > 0
-    ? exactMatches
-    : scored;
-  return ranked
-    .sort((left, right) => right.score - left.score || left.record.code.localeCompare(right.record.code))
-    .slice(0, limit);
+  return sortedMccRecords(records)
+    .filter((record) => normalizeSearch(record.name) === normalizedQuery)
+    .map((record) => record.code)
+    .slice(0, 8);
 }
 
 function createMccSelectionReceipt(productType, query, result, mccRunContext = captureMccRunContext()) {
@@ -628,7 +445,6 @@ function createMccSelectionReceipt(productType, query, result, mccRunContext = c
     mccRunContext.runId,
     productType,
     assertMccQuery(query),
-    JSON.stringify(result.semanticTerms || []),
     table.sha256,
     table.recordCount,
     codes
@@ -636,8 +452,8 @@ function createMccSelectionReceipt(productType, query, result, mccRunContext = c
   return `${mccSelectionReceiptPrefix}${codes}.${createHash('sha256').update(binding).digest('base64url')}`;
 }
 
-function resolveMccSelection(productType, query, selectedInput, receipt, records, semanticTerms, agentCandidateCodes, mccRunContext) {
-  const candidateCodes = mccSelectionReceiptCodes(productType, query, receipt, records, semanticTerms, mccRunContext);
+function resolveMccSelection(productType, query, selectedInput, receipt, records, mccRunContext) {
+  const candidateCodes = mccSelectionReceiptCodes(productType, query, receipt, records, mccRunContext);
   if (!candidateCodes) {
     const semanticStatus = typeof receipt === 'string' && receipt.startsWith(mccSelectionReceiptPrefix)
       ? 'SELECTION_RECEIPT_STALE'
@@ -646,10 +462,8 @@ function resolveMccSelection(productType, query, selectedInput, receipt, records
       query,
       productType,
       records,
-      semanticTerms,
       semanticStatus,
-      mccRunContext,
-      agentCandidateCodes
+      mccRunContext
     );
     return {
       ...refreshed,
@@ -666,8 +480,7 @@ function resolveMccSelection(productType, query, selectedInput, receipt, records
       deterministicCandidateCodes: [],
       deterministicStrongCandidateCodes: [],
       deterministicWeakCandidateCodes: [],
-      semanticCandidateCodes: [],
-      semanticTerms,
+      agentCandidateCodes: [],
       mergedCandidateCodes: candidateCodes,
       mccTableSummary: currentTable,
       candidates: candidateCodes.map((code) => mccCandidateFromRecord(records.get(code), productType, mccRunContext))
@@ -680,15 +493,14 @@ function resolveMccSelection(productType, query, selectedInput, receipt, records
     deterministicCandidateCodes: [],
     deterministicStrongCandidateCodes: [],
     deterministicWeakCandidateCodes: [],
-    semanticCandidateCodes: [],
-    semanticTerms,
+    agentCandidateCodes: [],
     mergedCandidateCodes: [selectedCode],
     mccTableSummary: currentTable,
     candidates: [candidate]
   };
 }
 
-function mccSelectionReceiptCodes(productType, query, receipt, records, semanticTerms, mccRunContext = captureMccRunContext()) {
+function mccSelectionReceiptCodes(productType, query, receipt, records, mccRunContext = captureMccRunContext()) {
   if (typeof receipt !== 'string' || !receipt.startsWith(mccSelectionReceiptPrefix)) return null;
   const body = receipt.slice(mccSelectionReceiptPrefix.length);
   const separator = body.lastIndexOf('.');
@@ -699,8 +511,7 @@ function mccSelectionReceiptCodes(productType, query, receipt, records, semantic
     || candidateCodes.some((code) => !records.has(code))
     || receipt !== createMccSelectionReceipt(productType, query, {
       mergedCandidateCodes: candidateCodes,
-      mccTableSummary: currentTable,
-      semanticTerms
+      mccTableSummary: currentTable
     }, mccRunContext)) {
     return null;
   }
@@ -711,10 +522,9 @@ function resolveMccResultFromRecords(
   query,
   productType,
   records,
-  semanticTerms = [],
   semanticStatus,
   mccRunContext = captureMccRunContext(),
-  agentCandidateCodes = []
+  agentReview = { provided: false, codes: [] }
 ) {
   const directCode = directMccCode(query, records);
   if (directCode.isCode) {
@@ -727,9 +537,7 @@ function resolveMccResultFromRecords(
         deterministicCandidateCodes: [code],
         deterministicStrongCandidateCodes: [code],
         deterministicWeakCandidateCodes: [],
-        semanticCandidateCodes: [],
         agentCandidateCodes: [],
-        semanticTerms,
         mergedCandidateCodes: [code],
         mccTableSummary: mccTableSummary(records),
         candidates: [candidate]
@@ -742,52 +550,69 @@ function resolveMccResultFromRecords(
       deterministicCandidateCodes: finalCodes,
       deterministicStrongCandidateCodes: finalCodes,
       deterministicWeakCandidateCodes: [],
-      semanticCandidateCodes: [],
       agentCandidateCodes: [],
-      semanticTerms,
       mergedCandidateCodes: finalCodes,
       mccTableSummary: mccTableSummary(records),
       candidates: finalCodes.map((code) => mccCandidateFromRecord(records.get(code), productType, mccRunContext))
     };
   }
 
-  const matches = deterministicMccMatches(query, records, { limit: 8, semanticTerms });
-  const deterministicCodes = matches.filter(({ originalEligible }) => originalEligible).map(({ record }) => record.code);
-  const semanticCodes = matches.filter(({ semanticEligible }) => semanticEligible).map(({ record }) => record.code);
-  const hasExactSemanticName = matches.some(({ semanticExactName }) => semanticExactName);
-  const localCodes = matches.map(({ record }) => record.code);
-  const mergedCodes = [...agentCandidateCodes, ...localCodes]
-    .filter((code, index, all) => all.indexOf(code) === index);
-  const finalCodes = mergedCodes.slice(0, 8);
+  const exactNameCodes = directMccName(query, records);
+  if (exactNameCodes.length > 0) {
+    const candidates = exactNameCodes.map((code) => mccCandidateFromRecord(records.get(code), productType, mccRunContext));
+    return {
+      matchType: candidates.length === 1 ? 'UNIQUE' : 'MULTIPLE',
+      semanticStatus: 'NOT_REQUIRED_EXACT_NAME',
+      deterministicCandidateCodes: exactNameCodes,
+      deterministicStrongCandidateCodes: exactNameCodes,
+      deterministicWeakCandidateCodes: [],
+      agentCandidateCodes: [],
+      mergedCandidateCodes: exactNameCodes,
+      mccTableSummary: mccTableSummary(records),
+      candidates
+    };
+  }
+
+  if (!agentReview.provided) {
+    return {
+      matchType: 'NONE',
+      semanticStatus: semanticStatus || 'AGENT_CATALOG_REVIEW_REQUIRED',
+      deterministicCandidateCodes: [],
+      deterministicStrongCandidateCodes: [],
+      deterministicWeakCandidateCodes: [],
+      agentCandidateCodes: [],
+      mergedCandidateCodes: [],
+      mccTableSummary: mccTableSummary(records),
+      candidates: [],
+      agentReview: {
+        required: true,
+        attempt: 1,
+        maxAttempts: 2,
+        reason: 'NATURAL_LANGUAGE_MATCH',
+        instructions: {
+          keepExplicitConstraints: true,
+          keepUnspecifiedDimensionsOpen: true,
+          excludeContradictions: true,
+          rankByRelevance: true,
+          maxCandidates: 8
+        },
+        catalog: mccCatalogForAgent(records)
+      }
+    };
+  }
+
+  const finalCodes = agentReview.codes;
   const candidates = finalCodes.map((code) => mccCandidateFromRecord(records.get(code), productType, mccRunContext));
-  const needsAgentReview = agentCandidateCodes.length === 0
-    && (
-      matches.length === 0
-      || deterministicCodes.length !== 1
-      || (semanticTerms.length > 0 && deterministicCodes.length === 0 && !hasExactSemanticName)
-    );
   return {
     matchType: candidates.length === 1 ? 'UNIQUE' : candidates.length === 0 ? 'NONE' : 'MULTIPLE',
-    semanticStatus: semanticStatus
-      || (agentCandidateCodes.length > 0 ? 'AGENT_CATALOG_REVIEW_USED' : semanticTerms.length > 0 ? 'AGENT_SEMANTIC_TERMS_USED' : 'DYNAMIC_CATALOG'),
-    deterministicCandidateCodes: deterministicCodes,
-    deterministicStrongCandidateCodes: deterministicCodes,
+    semanticStatus: semanticStatus || 'AGENT_CATALOG_REVIEW_USED',
+    deterministicCandidateCodes: [],
+    deterministicStrongCandidateCodes: [],
     deterministicWeakCandidateCodes: [],
-    semanticCandidateCodes: semanticCodes,
-    agentCandidateCodes,
-    semanticTerms,
+    agentCandidateCodes: finalCodes,
     mergedCandidateCodes: finalCodes,
     mccTableSummary: mccTableSummary(records),
-    candidates,
-    ...(needsAgentReview ? {
-      agentReview: {
-        required: true,
-        attempt: 1,
-        maxAttempts: 1,
-        reason: 'LOW_CONFIDENCE_LOCAL_MATCH',
-        catalog: mccCatalogForAgent(records)
-      }
-    } : {})
+    candidates
   };
 }
 
@@ -837,7 +662,9 @@ async function runMccResolvePlan(args) {
   const selected = optional(args, 'select');
   const selectionReceipt = optional(args, 'selection-receipt');
   const selectionState = optional(args, 'selection-state');
-  const semanticTerms = parseMccSemanticTerms(args);
+  if (args['semantic-terms-json'] !== undefined) {
+    throw new Error('mcc-resolve-plan 不再接受 --semantic-terms-json；自然语言只使用一次受限目录判断');
+  }
   if ((selected === undefined) !== (selectionReceipt === undefined)) {
     throw new Error('--select 与 --selection-receipt 必须同时提供');
   }
@@ -853,8 +680,8 @@ async function runMccResolvePlan(args) {
   const records = recordsForArgs(args);
   const agentReview = parseAgentCandidateRefs(args, records);
   let result = selected === undefined
-    ? resolveMccResultFromRecords(query, productType, records, semanticTerms, undefined, mccRunContext, agentReview.codes)
-    : resolveMccSelection(productType, query, selected, selectionReceipt, records, semanticTerms, agentReview.codes, mccRunContext);
+    ? resolveMccResultFromRecords(query, productType, records, undefined, mccRunContext, agentReview)
+    : resolveMccSelection(productType, query, selected, selectionReceipt, records, mccRunContext);
   if (selectionState === 'STALE') {
     result = {
       ...result,
@@ -891,14 +718,16 @@ async function runMccMatchCodes(args) {
   }
   await startTelemetryRun(rootIntent, productType);
   const query = required(args, 'query');
-  const semanticTerms = parseMccSemanticTerms(args);
+  if (args['semantic-terms-json'] !== undefined) {
+    throw new Error('mcc-match-codes 不再接受 --semantic-terms-json；自然语言只使用一次受限目录判断');
+  }
   if (args['agent-mcc-status'] !== undefined || args['agent-mcc-codes'] !== undefined) {
     throw new Error('mcc-match-codes 不接受 --agent-mcc-status 或 --agent-mcc-codes；MCC 匹配只使用本轮动态 catalog');
   }
   const records = recordsForArgs(args);
   const agentReview = parseAgentCandidateRefs(args, records);
   const mccRunContext = captureMccRunContext();
-  const result = resolveMccResultFromRecords(query, productType, records, semanticTerms, undefined, mccRunContext, agentReview.codes);
+  const result = resolveMccResultFromRecords(query, productType, records, undefined, mccRunContext, agentReview);
   const { candidates: _internalCandidates, ...controlResult } = result;
   process.stderr.write(`ALIPAY_AIPAY_INTERNAL:MCC_RESOLUTION=${JSON.stringify(controlResult)}\n`);
   return '';
@@ -908,14 +737,15 @@ function runMccValidateSelectionCache(args) {
   const productType = required(args, 'product-type');
   productFor({ ...args, 'product-type': productType });
   const records = recordsForArgs(args);
-  const semanticTerms = parseMccSemanticTerms(args);
+  if (args['semantic-terms-json'] !== undefined) {
+    throw new Error('mcc-validate-selection-cache 不再接受 --semantic-terms-json');
+  }
   const mccRunContext = captureMccRunContext();
   if (!mccSelectionReceiptCodes(
     productType,
     required(args, 'query'),
     required(args, 'selection-receipt'),
     records,
-    semanticTerms,
     mccRunContext
   )) {
     throw new Error('MCC 候选详情缓存与本轮选择回执不一致');

package/skill/references/normal/scripts/render_customer_message.mjs

@@ -1578,8 +1578,8 @@ export function renderMessage(messageId, variantName, variables, telemetryContex
     if (variables.overallResult === '未通过' && !hasFailedItems) {
       throw new Error('代码开发结果为未通过时必须列出未通过项');
     }
-    if (variables.overallResult === '通过' && hasBlockingDefect) {
-      throw new Error('代码开发通过时不得存在其他阻塞缺口');
+    if (hasBlockingDefect && variables.overallResult !== '未通过') {
+      throw new Error('存在代码、安全或必要依据阻塞缺口时，代码开发结果必须为未通过');
     }
     if (variables.overallResult !== '通过' && !sandboxPending && !hasBlockingDefect && !manualOnly) {
       throw new Error('沙箱已就绪且没有阻塞缺口时，非通过结果只能来自人工待验证项');
@@ -1605,12 +1605,12 @@ export function renderMessage(messageId, variantName, variables, telemetryContex
     if (variantName === 'WEBPAY' && variables.overallResult === '通过' && variables.webpayExperienceResult === '未提供浏览器付款入口或完整操作指引，需先补齐') {
       throw new Error('AI 网页应用收款未交付付款入口时不得标记代码开发通过');
     }
-    if (manualOnly) {
-      normalized.failedItems = `人工待验证项未完成：${normalized.manualItems}`;
-    }
     normalized.checklistDetails = variables.executionMode === '仅代码开发'
       ? ''
-      : `未完成项：${normalized.failedItems}\n人工待验证：${normalized.manualItems}`;
+      : [
+        ...(hasFailedItems ? [`未完成项：${normalized.failedItems}`] : []),
+        ...(hasManualItems ? [`人工待验证：${normalized.manualItems}`] : [])
+      ].join('\n');
     const productName = { AIPAY: 'AI 按量付费', WEBPAY: 'AI 网页应用收款', APPPAY: 'AI 移动应用收款' }[variantName];
     normalized.launchGuidance = variables.executionMode === '仅代码开发'
       ? productionReadinessBlock(productName, {

package/skill/references/onboarding/flow.md

@@ -13,7 +13,7 @@
 
 步骤顺序固定为方案展示后自动授权，再执行适用只读查询，最后处理独立分支。查询失败只阻断对应分支，不当作空列表；其他成功分支可继续。
 
-方案展示前只按本轮 `mcc.sh resolve-plan` 结果陈述 MCC 名称、描述和特殊资质。Agent 可从用户原始经营描述提炼有依据的行业概念和同义表达；本地词面结果不明确时，runner 会把同一次 `queryMcc` 返回的当前产品 MCC 名称和描述以一次性目录复核 marker 交给 Agent，Agent 只能返回目录引用，runner 再映射并校验为当前动态目录中的候选。`ar-support.queryMcc`、按需 `mccsearchservice.batchQueryMcc` 及候选快照的完整执行和失效规则见步骤 2；无查询依据的结论禁止推断。
+方案展示前只按本轮 `mcc.sh resolve-plan` 结果陈述 MCC 名称、描述和特殊资质。合法 MCC 编码和规范化后的完整类目名称由 runner 确定性匹配；其他自然语言由 Agent 对同一次 `queryMcc` 返回的当前产品完整 MCC 名称和描述做一次受限目录判断。Agent 只能返回目录引用，runner 再映射并校验为当前动态目录中的候选。`ar-support.queryMcc`、按需 `mccsearchservice.batchQueryMcc` 及候选快照的完整执行和失效规则见步骤 2；无查询依据的结论禁止推断。
 
 ---
 
@@ -103,29 +103,29 @@ node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-message prod
 
 产品明确但无经营描述/MCC：执行 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-message mcc-clarify --product-type "$PRODUCT_TYPE" --root-intent "$ROOT_INTENT" --agent-platform "<AGENT_PLATFORM>" --session-id "<SESSION_ID>"`。该命令必须先创建或复用正式 telemetry run 并记录 `clarify_intent`；缺少或非法 `ROOT_INTENT` 时停止，不得继续 MCC 或授权。
 
-已有经营描述、二级类目名称或编码时，以原话作为 `MCC_SEARCH_QUERY` 进入唯一 MCC 解析/方案入口。非精确编码时，Agent 应先理解原话；遇到行业俗称、场景表达或目录不一定直接出现的用词时，在首次调用中一并传入 0 到 12 个有原话依据的行业概念、经营对象或同义表达，形成 `MCC_SEMANTIC_TERMS_JSON`；只传概念，不补原话无依据的行业。没有可靠扩展时省略，不追加用户确认。runner 在完整动态类目内做 NFKC、泛词剥离、标点边界内二/三元词组召回和动态稀有度排序；原始精确编码/完整名称决定性优先，其余原话与 Agent 辅助概念联合评分，语义项按 `0.7` 权重参与，名称证据高于描述，其他候选最多 8 项。若本地结果为 `NONE`、候选冲突或仅由低置信语义词产生，runner 只发出一次 `MCC_AGENT_REVIEW_REQUIRED`，其中包含当前动态目录的稳定引用、名称和描述；Agent 必须基于该目录返回最多 8 个引用，并在同一原始 query 下用 `--agent-candidate-refs-json` 重跑，runner 只接受本轮目录中的引用。目录复核不新增 MCP 或网络调用，也不替代本地校验；禁止业务词到 MCC 的硬编码点映射、自由提交 MCC code、远程语义或额外网络调用。
+已有经营描述、二级类目名称或编码时，以原话作为 `MCC_SEARCH_QUERY` 进入唯一 MCC 解析/方案入口。合法 MCC 编码或规范化后与完整二级类目名称相等时由 runner 直接匹配，不调用 Agent。其他自然语言由 runner 输出一次 `MCC_AGENT_REVIEW_REQUIRED`，其中包含当前动态目录的稳定引用、名称、描述及固定判断约束；Agent 阅读用户完整原话和完整目录，只返回按匹配度排序的 0 到 8 个目录引用。用户明确提供的行业、商品、服务对象、经营方式和场景都是筛选条件，与明确条件冲突的候选必须排除；用户没有说明的细分维度保持开放，不能擅自排除或补充经营范围。候选超过 8 项时只保留最相关的 8 项。禁止业务词到 MCC 的硬编码点映射、自由提交 MCC code、远程语义或额外网络调用。
 
-同一 `run + 用户输入 + 原始 MCC_SEARCH_QUERY + 产品` 的语义扩充最多重试 2 次。首次未提供语义词且结果为 `NONE`，或已提供语义词但结果仍为 `NONE` 且仍有预算时，`mcc.sh` 只输出唯一内部 `MCC_SEMANTIC_RETRY_REQUIRED`，stdout 为空；Agent 必须保留原始 query、复用同一 `USER_INPUT_ID`，根据原话补充此前未使用且有依据的概念后原样重跑本命令，不向用户展示中间无匹配。后续重试提交的语义词必须保留此前语义词并至少新增一个此前未使用的词；未新增或替换原语义词时不消耗额度，直接进入既有无匹配分支。`MCC_SEMANTIC_RETRY_REQUIRED` 的 `attempt` 从 1 到 2，达到 2 后不再产生该 marker；仍为 `NONE` 时输出下方既有无匹配文案并停止。精确 MCC 编码不存在不进入语义重试；网络/CLI 失败仍只走各自既有恢复分支。语义重试计数只保存在当前 run 的私有缓存中，不随 MCC 树缓存 TTL 过期，读写异常按已耗尽处理，禁止通过更换 query、重置参数或重复调用绕过上限。
+同一 `run + 产品 + USER_INPUT_ID + 原始 MCC_SEARCH_QUERY + 动态目录摘要` 的自然语言判断只允许一次；同一 `USER_INPUT_ID` 不得通过改写 query 重新发起判断。Agent 返回非 JSON 字符串数组、目录外或重复引用、超过 8 项等协议错误时，runner 只输出一次 `MCC_AGENT_REPAIR_REQUIRED`；Agent 必须基于 marker 中的同一目录和明确错误原因，只修正格式、去重、排序或裁剪为最多 8 项，再用同一 query、`USER_INPUT_ID` 和 `--agent-candidate-refs-json` 原样重跑。修复不得重新解释用户意图、扩大经营范围、重新查询目录或改变用户原话。第二次仍非法、判断或修复状态重复、动态目录变化、状态不可安全记录时立即输出既有 MCC 暂时无法处理正文并停止，不回退字符匹配、不再次调用 Agent、不进入授权或签约。合法空数组表示当前目录无匹配，直接输出既有无匹配文案并等待用户补充描述，不触发修复。
 
-`queryMcc` 树和多候选快照使用默认 1800 秒、本轮 run 私有缓存；无有效 run 不缓存。快照绑定产品、salesCode、原查询、规范化语义词、选择回执、候选树事实及按需取得的资格详情；有效命中原样复用，失效才重查。runner 只接受最多 12 项、单项 2 到 40 字符、总计不超过 240 字符的 JSON 字符串数组并拒绝 MCC 编码；Agent 参数错误时基于原话更正或省略，不要求用户重述。两种 MCP 请求体不变；`batchQueryMcc` 最多一次，只传树内命中且 `needSpecialQual=true` 的候选编码。
+`queryMcc` 树和多候选快照使用默认 1800 秒、本轮 run 私有缓存；无有效 run 不缓存。快照绑定产品、salesCode、原查询、选择回执、候选树事实及按需取得的资格详情；有效命中原样复用，失效才重查。两种 MCP 请求体不变；`batchQueryMcc` 最多一次，只传 Agent 最终候选中 `needSpecialQual=true` 的编码。
 
 ```bash
-node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" mcc resolve-plan --query "$MCC_SEARCH_QUERY" --product-type "$PRODUCT_TYPE" --root-intent "$ROOT_INTENT" [--semantic-terms-json "$MCC_SEMANTIC_TERMS_JSON"] [--agent-candidate-refs-json "$MCC_AGENT_CANDIDATE_REFS_JSON"] --input-id "$USER_INPUT_ID" [--telemetry-run-id "$RUN_ID" --telemetry-history-count "$HISTORY_COUNT"] --agent-platform "<AGENT_PLATFORM>" --session-id "<SESSION_ID>"
+node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" mcc resolve-plan --query "$MCC_SEARCH_QUERY" --product-type "$PRODUCT_TYPE" --root-intent "$ROOT_INTENT" [--agent-candidate-refs-json "$MCC_AGENT_CANDIDATE_REFS_JSON"] --input-id "$USER_INPUT_ID" [--telemetry-run-id "$RUN_ID" --telemetry-history-count "$HISTORY_COUNT"] --agent-platform "<AGENT_PLATFORM>" --session-id "<SESSION_ID>"
 ```
 
-只收唯一 `ALIPAY_AIPAY_INTERNAL:MCC_QUERY_RESULT=SUCCESS` 与 `ALIPAY_AIPAY_INTERNAL:MCC_RESOLUTION=<json>`。若同时收到唯一 `ALIPAY_AIPAY_INTERNAL:MCC_AGENT_REVIEW_REQUIRED=<json>` 且 stdout 为空，Agent 读取其中稳定引用、名称和描述，最多返回 8 个当前目录引用后用同一 query、语义词和 `USER_INPUT_ID` 原样重跑一次；不得把该 marker 或中间状态展示给用户。目录复核最多一次，不消耗语义扩充预算；未返回有效引用时沿用本地结果并继续既有 `NONE`/候选分支。若同时收到唯一 `ALIPAY_AIPAY_INTERNAL:MCC_SEMANTIC_RETRY_REQUIRED=<json>` 且 stdout 为空，按上面的规则在同一工作回合自动重跑；不得把该 marker 或中间状态展示给用户。`UNIQUE` 恰一项，并有唯一 `CUSTOMER_MESSAGE_DELIVERY_REQUIRED=onboarding.plan.confirm`、`MCC_CONTEXT_RECEIPT`；先把 stdout 作为可见进行中消息原文送达，随后同一回合进入 `execute`，不等待回复。`MULTIPLE` 送候选后等待；预算耗尽的 `NONE` 送既有无匹配文案后等待用户重新描述。禁止旧 `mcc-search`/`mcc-candidates`、手写候选或近似追问。
+只收唯一 `ALIPAY_AIPAY_INTERNAL:MCC_QUERY_RESULT=SUCCESS` 与适用的内部结果。若同时收到唯一 `MCC_AGENT_REVIEW_REQUIRED` 且 stdout 为空，Agent 按上面的判断约束返回 0 到 8 个当前目录引用并原样重跑一次；若收到唯一 `MCC_AGENT_REPAIR_REQUIRED` 且 stdout 为空，只做一次协议修复并原样重跑。两个 marker 和中间状态都不得展示给用户。`UNIQUE` 恰一项，并有唯一 `CUSTOMER_MESSAGE_DELIVERY_REQUIRED=onboarding.plan.confirm`、`MCC_CONTEXT_RECEIPT`；先把 stdout 作为可见进行中消息原文送达，随后同一回合进入 `execute`，不等待回复。`MULTIPLE` 送候选后等待；合法 `NONE` 送既有无匹配文案后等待用户重新描述。禁止旧 `mcc-search`/`mcc-candidates`、手写候选或近似追问。
 
 `MCC_FLOW:RETRY_WITH_NETWORK`：联网后原样重试同一 `mcc resolve-plan`。`CLI_FLOW:RETRY_WITH_LOCAL_FS_PERMISSION` 且 stdout 空：给同命令 CLI 私有状态目录权限后原样重试。失败停 MCC；禁无匹配兜底或进方案/授权/签约。
 
-`ALIPAY_AIPAY_INTERNAL:MCC_QUERY_RESULT=FAILED` 且无 `MCC_FLOW:RETRY_WITH_NETWORK`：送stdout，停MCC；非无匹配，禁候选/方案/授权/签约。
+`ALIPAY_AIPAY_INTERNAL:MCC_QUERY_RESULT=FAILED` 且无 `MCC_FLOW:RETRY_WITH_NETWORK`：送 stdout，停 MCC；非无匹配，禁候选/方案/授权/签约。只有用户按 stdout 指引重新发送经营描述后才开始新一轮匹配：先按统一前置规则计数，把该聊天消息原话作为新的 `MCC_SEARCH_QUERY`，使用该消息新的 `USER_INPUT_ID` 调用 `mcc resolve-plan`；不得复用上次的目录引用、修复 marker 或选择回执。即使用户原样重发经营描述，新 `USER_INPUT_ID` 也允许重新匹配。Agent 不得在没有新用户消息时自动发起第二轮，也不得因再次失败循环重试。
 
-`MULTIPLE` 还须取得唯一 `MCC_SELECTION_RECEIPT`。用户回复序号、当前候选完整名称或编码时，以原始 `MCC_SEARCH_QUERY` 和首次检索使用的同一 `MCC_SEMANTIC_TERMS_JSON` 重跑同一入口：`node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" mcc resolve-plan --query "$MCC_SEARCH_QUERY" --product-type "$PRODUCT_TYPE" --root-intent "$ROOT_INTENT" [--semantic-terms-json "$MCC_SEMANTIC_TERMS_JSON"] --select "$SELECTED_MCC_CODE" --selection-receipt "$MCC_SELECTION_RECEIPT" --input-id "$USER_INPUT_ID" --telemetry-run-id "$RUN_ID" --telemetry-history-count "$HISTORY_COUNT" --agent-platform "<AGENT_PLATFORM>" --session-id "<SESSION_ID>"`。有效详情快照直接生成方案，不再调用 `queryMcc` 或 `batchQueryMcc`；runner 仍校验当前 run、产品、原话、规范化语义词、候选和事实哈希。receipt 或快照失效时不得沿用或自动套用旧选择，必须基于完整当前产品目录重新召回并至少重新展示一次当前候选。
+`MULTIPLE` 还须取得唯一 `MCC_SELECTION_RECEIPT`。用户回复序号、当前候选完整名称或编码时，以原始 `MCC_SEARCH_QUERY` 重跑同一入口：`node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" mcc resolve-plan --query "$MCC_SEARCH_QUERY" --product-type "$PRODUCT_TYPE" --root-intent "$ROOT_INTENT" --select "$SELECTED_MCC_CODE" --selection-receipt "$MCC_SELECTION_RECEIPT" --input-id "$USER_INPUT_ID" --telemetry-run-id "$RUN_ID" --telemetry-history-count "$HISTORY_COUNT" --agent-platform "<AGENT_PLATFORM>" --session-id "<SESSION_ID>"`。有效详情快照直接生成方案，不再调用 `queryMcc` 或 `batchQueryMcc`；runner 仍校验当前 run、产品、原话、候选和事实哈希。receipt 或快照失效时不得沿用或自动套用旧选择，必须基于完整当前产品目录重新判断并至少重新展示一次当前候选。
 
 用户指定的 MCC 不在候选中时，按该 MCC 重新查询，不沿用旧候选回执，也不要要求用户换类目。
 
 `salesCode`、`scope` 和基础材料只取“产品映射”。方案只由 `mcc resolve-plan` 或已有唯一 MCC 事实时的 `onboarding-message plan-confirm --root-intent "$ROOT_INTENT" --mcc-context-receipt ... [--telemetry-run-id "$RUN_ID" --telemetry-history-count "$HISTORY_COUNT"]` 生成，展示产品/scope、MCC、特殊资质、企业账号边界及商家平台链接。已有 active run 时必须传 telemetry 参数；如果该命令首次创建 run，则尚无 marker，省略参数并由同一进程把本次 plan stage 的 history 固定为 0，命令返回后取得后续使用的 `RUN_ID`。`ROOT_INTENT` 取当前路线根意图，只能是 `onboarding_only` 或 `full_process`。特殊资质只来自 `qualificationGroups`：多个 group 是 OR 关系；同一 group 内多个 qualifications 是 AND 关系；`attaType` 为空或 null 的 qualification 只展示 `qualName`，不生成上传项。禁止补充模板外资格或审核规则。
 
-不得保留“先运行旧字符串搜索，无匹配后再临时让 Agent 猜”的无边界两阶段流程，或重复询问已知信息；目录复核是完整 `queryMcc` 事实上的一次受限 Agent 判断，必须在 `MCC_AGENT_REVIEW_REQUIRED` marker 后立即完成，最多一次且不增加用户确认。语义重试只允许按上一段登记的两次预算执行。语义概念、目录引用与原话必须在同一次 `resolve-plan` 中提交并统一校验。唯一事实校验通过、方案 marker 唯一且 stdout 已送达后，执行 `onboarding-execute-ready --product-type "$PRODUCT_TYPE"`；缺值/冲突/非唯一继续澄清，产品/MCC 变更重渲染。`execute` loader 只继承 `clarify_intent` 已记录的正式 run 事实，不再单独记录 stage，不代表新增用户回复，禁手工上报；Agent 在收到每条聊天框用户消息时，必须先按 `runtime-entry.md` 的统一前置命令计数，不按是否与 Skill 相关筛选，`summary` 收口后不再计入当前 run，`full_process` 不重置。
+不得保留“先运行旧字符串搜索，无匹配后再临时让 Agent 猜”的两阶段流程，或重复询问已知信息；自然语言只允许完整动态目录上的一次受限 Agent 判断和一次协议修复，二者预算由本轮私有状态原子固定。唯一事实校验通过、方案 marker 唯一且 stdout 已送达后，执行 `onboarding-execute-ready --product-type "$PRODUCT_TYPE"`；缺值/冲突/非唯一继续澄清，产品/MCC 变更重渲染。`execute` loader 只继承 `clarify_intent` 已记录的正式 run 事实，不再单独记录 stage，不代表新增用户回复，禁手工上报；Agent 在收到每条聊天框用户消息时，必须先按 `runtime-entry.md` 的统一前置命令计数，不按是否与 Skill 相关筛选，`summary` 收口后不再计入当前 run，`full_process` 不重置。
 
 <!-- ALIPAY_AIPAY_FLOW:ONBOARDING_ENTRY:END -->
 

package/skill/references/onboarding/modules/product-sign.md

@@ -13,7 +13,7 @@
 
 `queryMcc`、签约查询和签约提交使用 `{"request":{...},"ctx":{}}`；`batchQueryMcc` 使用 `{"request":{"mccCodes":[...]}}`。完整 payload 只在脚本中维护；Agent 不从本模块自行构造 MCP 调用。
 
-`queryMcc` 成功树按同一 run、产品短时缓存，并逐项提供二级 MCC 编码、名称、描述和布尔型 `needSpecialQual`；任一必需字段缺失、为空或类型异常均失败关闭，不从其他字段回退。非精确编码时，Agent 应先理解用户原话，并在行业俗称或场景表达与目录用词可能不同时于首次调用一并提供有原话依据的行业概念或同义表达；本地词面结果为 `NONE`、候选冲突或低置信时，runner 可发出一次目录复核 marker，携带同一次 `queryMcc` 返回的当前产品 MCC 名称、描述和稳定引用；Agent 只返回该 marker 中的目录引用，runner 映射并校验为当前动态目录中的候选，不接受自由提交 MCC code。稳定引用由完整动态目录生成，并随候选裁剪和资格详情合并原样携带；最终方案 runner 不得按缩减后的候选数组重新编号。目录复核不新增 MCP/网络调用，语义扩充仍按 flow 最多完成两次。候选确定后，仅把其中 `needSpecialQual=true` 的编码集中交给一次 `batchQueryMcc` 获取特殊资质项；没有此类候选时不调用。多候选的完整树事实和资格详情按 run、产品、原查询、规范化语义词和选择回执缓存，用户选择时携带同一语义词且有效命中则两种 MCC 方法都不重调。缓存默认 1800 秒、无有效 run 不落盘；过期、损坏、符号链接、跨 run、语义词变化或事实哈希不一致时忽略并从完整当前产品目录重查，不修补缓存事实，不做产品级全量预取。
+`queryMcc` 成功树按同一 run、产品短时缓存，并逐项提供二级 MCC 编码、名称、描述和布尔型 `needSpecialQual`；任一必需字段缺失、为空或类型异常均失败关闭，不从其他字段回退。合法 MCC 编码和规范化完整类目名称由 runner 确定性匹配；其他自然语言由 Agent 基于用户完整原话和同一次 `queryMcc` 返回的当前产品完整 MCC 名称、描述做一次受限判断，只返回按匹配度排序的最多 8 个稳定目录引用。用户明确约束用于排除冲突候选，未说明的维度保持开放。稳定引用由完整动态目录生成，并随候选裁剪和资格详情合并原样携带；最终方案 runner 不得按缩减后的候选数组重新编号。非法 Agent 结果只允许一次协议修复，第二次失败立即停止，不回退字符匹配或重复 Agent 判断。候选确定后，仅把其中 `needSpecialQual=true` 的编码集中交给一次 `batchQueryMcc` 获取特殊资质项；没有此类候选时不调用。多候选的完整树事实和资格详情按 run、产品、原查询和选择回执缓存，有效选择时两种 MCC 方法都不重调。缓存默认 1800 秒、无有效 run 不落盘；过期、损坏、符号链接、跨 run 或事实哈希不一致时忽略并从完整当前产品目录重新判断，不修补缓存事实，不做产品级全量预取。
 
 ## 签约状态