@alipay/alipay-aipay 1.8.3 → 1.8.5

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/profile.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const maxProfileBytes = 64 * 1024;
+const validProfileValue = value => typeof value === 'string' && value.trim() === value
+  && [...value].length >= 1 && [...value].length <= 128 && !/[\p{Cc}\p{Cs}]/u.test(value);
+
+function readProfileFields(skillDir) {
+  try {
+    if (typeof skillDir !== 'string' || !path.isAbsolute(skillDir)) return {};
+    const file = path.join(skillDir, 'PROFILE');
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > maxProfileBytes) return {};
+    const profile = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!profile || Array.isArray(profile) || profile.schemaVersion !== 1) return {};
+    return {
+      chinfo: validProfileValue(profile.chinfo) ? profile.chinfo : '',
+      vid: validProfileValue(profile.vid) ? profile.vid : '',
+    };
+  } catch {
+    return {};
+  }
+}
+
+export function readProfileChinfo(skillDir) { return readProfileFields(skillDir).chinfo || ''; }
+export function readProfileVid(skillDir) { return readProfileFields(skillDir).vid || ''; }
+
+export function runProfileCli(argv = process.argv) {
+  if (argv.length === 5 && argv[2] === 'read-chinfo' && argv[3] === '--skill-dir') {
+    process.stdout.write(readProfileChinfo(argv[4]));
+    return 0;
+  }
+  if (argv.length === 7 && argv[2] === 'merge-biz-info' && argv[3] === '--skill-dir' && argv[5] === '--base-json') {
+    try {
+      const base = JSON.parse(argv[6]);
+      if (!base || Array.isArray(base) || typeof base !== 'object') return 1;
+      const fields = readProfileFields(argv[4]);
+      if (fields.chinfo) base.chinfo = fields.chinfo;
+      if (fields.vid) base.vid = fields.vid;
+      process.stdout.write(JSON.stringify(base));
+      return 0;
+    } catch { return 1; }
+  }
+  return 1;
+}
+
+if (process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url))) {
+  process.exitCode = runProfileCli();
+}

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

@@ -35,6 +35,7 @@ function filesUnder(root) {
     else throw Error('Non-regular session Skill file');
   };
   for (const entry of ['SKILL.md','VERSION','references']) walk(entry);
+  if (fs.existsSync(path.join(root,'PROFILE'))) walk('PROFILE');
   return files;
 }
 function identity(root, channel, version) {
@@ -48,15 +49,20 @@ function identity(root, channel, version) {
         (channel==='pre'?'alipay-aipay-pre':'alipay-aipay')) throw Error('Session Skill identity mismatch');
 }
 
-export function createSessionSkill({sourceDir, channel, version, packageVersion, targetDir, home = os.homedir()}) {
+export function createSessionSkill({sourceDir, channel, version, packageVersion, targetDir, profileContent, home = os.homedir()}) {
   identity(sourceDir, channel, version);
   if (!semver.test(packageVersion) || !path.isAbsolute(targetDir)) throw Error('Invalid session install source');
-  const manifest = filesUnder(sourceDir);
   const root = privateRoot(home);
   const skillDir = path.join(root, `${channel}-${version}-${randomUUID()}`);
   fs.mkdirSync(skillDir, {mode:0o700});
   try {
     for (const entry of ['SKILL.md','VERSION','references']) fs.cpSync(path.join(sourceDir,entry),path.join(skillDir,entry),{recursive:true,errorOnExist:true,force:false});
+    const selectedProfile = profileContent === undefined ? readProfile(targetDir) : profileContent;
+    if (selectedProfile !== null && selectedProfile !== undefined) {
+      if (!(Buffer.isBuffer(selectedProfile) || selectedProfile instanceof Uint8Array) || selectedProfile.length > 64 * 1024) throw Error('Invalid PROFILE content');
+      fs.writeFileSync(path.join(skillDir,'PROFILE'),selectedProfile,{flag:'wx',mode:0o600});
+    }
+    const manifest = filesUnder(skillDir);
     const receipt = {schemaVersion:1, scope:'session', channel, version, packageVersion,
       skillDir:fs.realpathSync(skillDir), targetDir:path.resolve(targetDir)};
     fs.writeFileSync(path.join(skillDir,receiptName),JSON.stringify({...receipt,manifest}),{flag:'wx',mode:0o600});
@@ -68,6 +74,15 @@ export function createSessionSkill({sourceDir, channel, version, packageVersion,
   }
 }
 
+function readProfile(skillDir) {
+  const file=path.join(skillDir,'PROFILE');
+  if (!fs.existsSync(file)) return null;
+  plain(file);
+  const stat=fs.lstatSync(file);
+  if (stat.size > 64 * 1024) throw Error('PROFILE is too large');
+  return fs.readFileSync(file);
+}
+
 export function verifySessionSkill(receipt, {home = os.homedir(), channel, version, packageVersion, targetDir} = {}) {
   if (!receipt || receipt.schemaVersion!==1 || receipt.scope!=='session' || !['stable','pre'].includes(receipt.channel) || !semver.test(receipt.version||'') || !path.isAbsolute(receipt.skillDir||'') ||
       !path.isAbsolute(receipt.targetDir||'') || !semver.test(receipt.packageVersion||'')) throw Error('Invalid session receipt');

package/skill/references/normal/self-update.md

@@ -4,6 +4,8 @@
 
 唯一 stderr 终态：`SELF_UPDATE:CURRENT=<合法 SemVer>`、`SELF_UPDATE:UPDATED=<合法 SemVer>`、`SELF_UPDATE:SESSION_READY=<合法 SemVer>`、`SELF_UPDATE:RETRY_WITH_NETWORK`、`SELF_UPDATE:SKIPPED_NETWORK_RESTRICTED`、`SELF_UPDATE:CHECK_FAILED`、`SELF_UPDATE:INSTALL_FAILED`、`SELF_UPDATE:VERIFY_FAILED`。`UPDATED` 用原子替换后的新版，除 `SESSION_READY` 外其余用当前可用版；marker 异常读当前入口，不得称最新或更新成功；停止读旧版，读取同一根目录的新版入口。仅 `RETRY_WITH_NETWORK` 可取权后原样重试一次，拒绝、不支持或再次返回时读当前入口；一次网络恢复外，不重查、取权、用 `sudo`、要求用户操作或写更新状态。每次只查一次 npm latest 的 `version` 和 `alipayAipayChannels`；只比较本渠道 Skill 版本，npm 包版本仅用于精确下载；`VERSION` 缺失、非法、落后或业务入口缺失时只从查询所得精确 npm 包版本安装当前渠道一次。渠道由当前目录的 `references/normal/json/release-channel.json` 与 Skill 名称共同校验；旧正式版缺少渠道文件时只兼容 `stable`，预发版禁止回退正式版。缺少或非法的远端渠道元数据返回 `CHECK_FAILED`，不得按 npm 包版本兜底。不调用公开 `install --target all`；超时终止同一次调用的进程树并清理。
 
+公开 npm `install` 是 `PROFILE` 的唯一创建入口：`chinfo` 显式传值时更新为该来源，未传时更新为 `origin`；只有显式 `--vid <值>` 才新增或更新 `vid`，未传时保留已有 `vid`，其他已有扩展字段也保留。自更新只原样迁移当前 Skill 根目录已有的普通 `PROFILE`；不存在时新版及 Windows 会话副本都保持不存在。内部 `npx ... install-current` 不属于用户主动安装，禁止创建 `origin` 或修改 `vid`。源包的 `skill/` 与 `skill-pre/` 不包含 `PROFILE`。
+
 本地正式渠道的 `X.Y.Z-beta`、`X.Y.Z-betaN`（兼容 `-beta.N`）和预发渠道的 `X.Y.Z-pre-beta`、`X.Y.Z-pre-betaN` 均为固定测试版本。完整安装直接返回 `CURRENT` 且不查询 npm；业务入口损坏时返回 `VERIFY_FAILED`，仍不下载修复或转正。更换版本必须由测试人员显式执行 npm 安装器的 `install`，普通 `update` 同样不推进 beta。正常版本分别为 `X.Y.Z` 与 `X.Y.Z-pre`，远端对应渠道若为 beta 或名称不匹配，返回 `CHECK_FAILED`，不自动安装。beta 不参与版本排序，无自动追踪和自动转正。
 
 `SESSION_READY` 是 Windows 目录占用或权限失败的有限恢复：只有替换前的备份/暂存准备失败，安装器才从本次精确 npm 包创建并逐文件 SHA-256 复核独立副本；不混合覆盖原目录，不更新全局安装记录。必须同时取得唯一 `ALIPAY_AIPAY_INTERNAL:SELF_UPDATE_SESSION_SKILL_DIR=<JSON 字符串>`，用已核验的绝对路径重绑 `SKILL_DIR`，明确告知“全局目录未更新，当前会话使用已校验的新版本；下次会话仍可能加载旧版”。废弃旧 loaded/CLI 刷新事实，保留本渠道自更新已检查事实，立即读取新路径的 `SKILL.md` 并继续其余启动协议，禁止再次自更新。内测版仍需按新路径/版本完成声明及服务/采集选择，安装意图不得代替采集同意。路径 marker 缺失、冲突或新入口不可读时，不切换、不声称更新成功，使用仍可用的原目录或说明入口不可用。