@alipay/alipay-aipay 1.6.2-beta3 → 1.6.3-beta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alipay/alipay-aipay",
-  "version": "1.6.2-beta3",
+  "version": "1.6.3-beta",
   "description": "支付宝 AI 付 Skill 安装包 - 优先安装 Agent Skill，并在 macOS/Linux 后台准备用户级 CLI 工具",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -5,23 +5,27 @@ description: >-
   触发关键词："AI支付"、"接支付宝"、"一站式接支付宝"、"接个支付"、"开发支付"、"402收款"、"AI按量付费"、"AI网页应用收款"、"AI移动应用收款"、"按量付费"、"快捷收款"、"快捷收单"、"网站支付"、"APP 支付"、"产品开通"、"商家开通"、"签约入驻"等。
 ---
 
-本文件只负责在加载业务规则前确定本轮实际使用的 Skill 版本。禁止在完成下列启动协议前读取 `references/runtime-entry.md`、flow、模块、消息目录或业务脚本。
+# 支付宝 AI 付 Skill 启动器
 
-首次使用 `alipay-aipay`：解析本文件目录为规范化绝对 `<SKILL_DIR>`，记录 `ALIPAY_AIPAY_SELF_UPDATE_CHECKED=true`，执行单命令；`<SKILL_DIR>` 是占位符，禁止用 shell 变量赋值、命令替换或依赖特定 shell：
+本文件只负责在加载业务规则前确定本轮实际使用的 Skill 版本。禁止在完成下列启动协议前读取 `references/runtime-entry.md`、任一 flow、模块、消息目录或业务脚本。
+
+## 前置版本检查
+
+本次 Agent 对话首次使用 `alipay-aipay` 时，先把本文件所在目录解析为规范化绝对路径 `<SKILL_DIR>`，记录一次性事实 `ALIPAY_AIPAY_SELF_UPDATE_CHECKED=true`，再执行以下单条命令。`<SKILL_DIR>` 是执行时替换的路径占位符；禁止用 shell 变量赋值、命令替换或依赖特定 shell：
 
 ```text
 node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" self-update check --skill-dir "<SKILL_DIR>"
 ```
 
-`SKILL_DIR` 只绑定当前 Skill，禁止换成 Agent 启动目录、用户项目、Home、npm 源码根或其他副本。`VERSION` 缺失/非法或入口缺失由命令修复；失败或 marker 不唯一按 `SELF_UPDATE:CHECK_FAILED`。
+`SKILL_DIR` 必须绑定刚触发且正在执行本命令的 Skill 规范化绝对路径，不得换成 Agent 启动目录、用户项目目录、用户 Home、npm 包源码根或另一份 Skill 副本。`VERSION` 缺失/非法或 `references/runtime-entry.md` 缺失时由本命令尝试精确修复；命令失败或 marker 无法唯一解析时按 `SELF_UPDATE:CHECK_FAILED`。
 
-stderr 只允许一个内部终态，禁止展示 marker 或 npm/npx 原始输出：
+stderr 只允许出现以下一个内部终态；不得向用户展示 marker 或 npm/npx 原始输出：
 
-- `SELF_UPDATE:UPDATED=<合法 SemVer>`：已切换新版。
+- `SELF_UPDATE:UPDATED=<合法 SemVer>`：当前 Skill 目录已原子切换到新版。
 - `SELF_UPDATE:CURRENT=<合法 SemVer>`：继续当前版本。
-- `SELF_UPDATE:RETRY_WITH_NETWORK`：可取权后原样重试一次。
-- `SELF_UPDATE:SKIPPED_NETWORK_RESTRICTED|CHECK_FAILED|INSTALL_FAILED|VERIFY_FAILED`：继续当前可用版本。
+- `SELF_UPDATE:RETRY_WITH_NETWORK`：registry 或安装阶段网络不可达；可申请联网后原样重试本命令一次。
+- `SELF_UPDATE:SKIPPED_NETWORK_RESTRICTED|CHECK_FAILED|INSTALL_FAILED|VERIFY_FAILED`：静默继续当前可用版本，不重试、不申请权限。
 
-除 `RETRY_WITH_NETWORK` 外，只完整读取同一 `SKILL_DIR` 的 `references/runtime-entry.md`，记录 `ALIPAY_AIPAY_RUNTIME_ENTRY_LOADED=true` 和路径，再路由。`UPDATED` 后废弃旧 loaded 事实，禁止继续读取更新前版本的任何业务文档；其他终态同样不再读取本启动器或 `self-update.md` 补充规则。
+除 `RETRY_WITH_NETWORK` 的一次原样重试外，只完整读取同一 `SKILL_DIR` 的 `references/runtime-entry.md`，在当前上下文记录 `ALIPAY_AIPAY_RUNTIME_ENTRY_LOADED=true` 和规范化路径，再按原请求路由。`UPDATED` 后先废弃旧 loaded 事实，禁止继续读取更新前版本的任何业务文档；其他终态同样不再读取本启动器或 `self-update.md` 补充规则。
 
-同一对话后续确认、补材料、候选、恢复、中断继续、重复触发和 Full Process 衔接，两项事实存在且路径未变时跳过版本检查和入口重读；仅 `UPDATED`、路径变化或上下文压缩导致规则不可用时重读并刷新；事实不落盘。
+同一对话后续确认、补材料、候选选择、恢复、中断继续、重复触发和 Full Process 衔接，两项事实存在、路径未变且入口规则仍在时，跳过版本检查和入口重读。仅 `UPDATED`、路径变化或上下文压缩导致规则不可用时重读并刷新；事实不落盘。

package/skill/VERSION

@@ -1 +1 @@
-1.6.2-beta3
+1.6.3-beta

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

@@ -1231,7 +1231,7 @@ function runProductClarify() {
 function runProductUnsupported(args) {
   return renderMessage('product.unsupported', 'DEFAULT', {
     productName: required(args, 'product-name')
-  }, terminalMetricContextFromArgs(args));
+  }, terminalMetricContextFromArgs(args, { terminalReason: 'unsupported_product' }));
 }
 
 function runWindowsSandboxSetup() {
@@ -1313,6 +1313,12 @@ function checklistInputFromArgs(args) {
   return input;
 }
 
+function terminalReasonForChecklist(input) {
+  if (input.overallResult === '通过') return 'completed';
+  if (input.overallResult === '未通过' || input.blockingDefectState === 'PRESENT') return 'integration_blocked';
+  return 'partial_with_remaining_actions';
+}
+
 async function runChecklistResult(args) {
   const variant = required(args, 'variant');
   if (!['AIPAY', 'WEBPAY', 'APPPAY'].includes(variant)) throw new Error('variant 非法，仅支持 AIPAY、WEBPAY、APPPAY');
@@ -1360,7 +1366,10 @@ async function runChecklistResult(args) {
     emitTerminalMetric({
       rootIntent: 'integration_only',
       productType: variant,
-      ...terminalMetricContextFromArgs(args, { rootIntent: 'integration_only' })
+      ...terminalMetricContextFromArgs(args, {
+        rootIntent: 'integration_only',
+        terminalReason: terminalReasonForChecklist(input)
+      })
     });
   }
   return rendered;

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

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
+import { recordTelemetryUserInputForCurrentPhase } from './telemetry.mjs';
 
 const internalPrefix = 'ALIPAY_AIPAY_INTERNAL:';
 const scriptDir = path.dirname(fileURLToPath(import.meta.url));
@@ -113,11 +114,18 @@ function parseArgs(argv) {
   return { command, args };
 }
 
+function required(args, name) {
+  const value = args[name];
+  if (typeof value !== 'string' || !value) throw new Error(`缺少参数 --${name}`);
+  return value;
+}
+
 export function runInteractionReplyCli(argv = process.argv) {
   const { command, args } = parseArgs(argv);
   if (command !== 'confirm' || typeof args.reply !== 'string' || !args.reply) {
-    throw new Error('用法: interaction_reply.mjs confirm --reply <用户原始回复>');
+    throw new Error('用法: interaction_reply.mjs confirm --reply <用户原始回复> --input-id <本地用户输入幂等键>');
   }
+  recordTelemetryUserInputForCurrentPhase(required(args, 'input-id'));
   const decision = isAffirmativeReply(args.reply) ? 'CONFIRMED' : 'REJECTED';
   process.stderr.write(`${internalPrefix}REPLY_DECISION=${decision}\n`);
   if (decision === 'REJECTED') process.exitCode = 2;

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

@@ -157,7 +157,7 @@ function runPlatformEntry(args = {}) {
   }
   return renderMessage('onboarding.windows.redirect', 'DEFAULT', {
     officialUrl: buildWindowsOnboardingRedirectUrl(runContext.run_id)
-  }, terminalMetricContextFromArgs(args));
+  }, terminalMetricContextFromArgs(args, { terminalReason: 'unsupported_platform' }));
 }
 
 function parseJsonArg(args, name, label) {
@@ -178,7 +178,12 @@ function runEnterpriseUnsupported(args) {
   if (!['ONBOARDING_ONLY', 'FULL_PROCESS'].includes(variant)) {
     throw new Error('variant 非法，仅支持 ONBOARDING_ONLY、FULL_PROCESS');
   }
-  return renderMessage('onboarding.enterprise.unsupported', variant, {}, terminalMetricContextFromArgs(args));
+  return renderMessage(
+    'onboarding.enterprise.unsupported',
+    variant,
+    {},
+    terminalMetricContextFromArgs(args, { terminalReason: 'enterprise_account_unsupported' })
+  );
 }
 
 async function runMccClarify(args) {
@@ -751,10 +756,18 @@ function closeoutInputFromArgs(args) {
 async function runCloseout(args) {
   const variables = closeoutInputFromArgs(args);
   const rendered = renderMessage('process.partial_result', 'DEFAULT', variables);
+  const terminalReason = args['root-intent'] === 'full_process' && variables.integrationResult !== '已完成'
+    ? 'partial_with_remaining_actions'
+    : variables.processResultTitle === '支付产品-产品开通已完成'
+      ? 'completed'
+      : 'partial_with_remaining_actions';
   emitTerminalMetric({
     productName: variables.productName,
     rootIntent: args['root-intent'],
-    ...terminalMetricContextFromArgs(args, { rootIntent: args['root-intent'] })
+    ...terminalMetricContextFromArgs(args, {
+      rootIntent: args['root-intent'],
+      terminalReason
+    })
   });
   return rendered;
 }

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

@@ -5,6 +5,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { isAffirmativeReply } from './interaction_reply.mjs';
+import { recordTelemetryUserInputForCurrentPhase } from './telemetry.mjs';
 
 const internalPrefix = 'ALIPAY_AIPAY_INTERNAL:';
 const scriptDir = path.dirname(fileURLToPath(import.meta.url));
@@ -33,6 +34,7 @@ function required(args, name) {
 }
 
 function assertRegisteredReply(args, kind) {
+  recordTelemetryUserInputForCurrentPhase(required(args, 'input-id'));
   if (!isAffirmativeReply(required(args, 'reply'))) {
     process.stderr.write(`${internalPrefix}RECOVERY_INPUT_REJECTED=${kind}\n`);
     process.exitCode = 2;
@@ -85,7 +87,7 @@ export function runOnboardingRecoveryCli(argv = process.argv) {
   const { command, args } = parseArgs(argv);
   if (command === 'auth-confirm') return runAuthConfirm(args);
   if (command === 'application-key') return runApplicationKeyRecovery(args);
-  throw new Error('用法: onboarding_recovery_runner.mjs <auth-confirm|application-key> --reply <明确完成表达> ...');
+  throw new Error('用法: onboarding_recovery_runner.mjs <auth-confirm|application-key> --reply <明确完成表达> --input-id <本地用户输入幂等键> ...');
 }
 
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {

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

@@ -132,19 +132,20 @@ function appendOptionalTerminalCountOptions(targetArgs, options) {
   }
 }
 
-async function startTelemetryRun(rootIntent, productType) {
+async function startTelemetryRun(rootIntent, productType, inputId = '') {
   const telemetryArgs = ['start-run', '--root-intent', rootIntent];
   if (productType) telemetryArgs.push('--product-type', productType);
+  if (inputId) telemetryArgs.push('--input-id', inputId);
   const { runTelemetryCli } = await import('./telemetry.mjs');
   await runTelemetryCli(cliArgv(telemetryArgs));
 }
 
 async function runIntegrationBootstrap(args) {
   const options = parseRuntimeArgs(args);
-  assertOnlyOptions(options, ['root-intent', 'product-type']);
+  assertOnlyOptions(options, ['root-intent', 'product-type', 'input-id']);
   const rootIntent = assertEnumOption(options, 'root-intent', ['integration_only']);
   const productType = assertEnumOption(options, 'product-type', ['aipay', 'webpay', 'apppay'], { required: false });
-  await startTelemetryRun(rootIntent, productType);
+  await startTelemetryRun(rootIntent, productType, options['input-id']);
   const { runFlowCli } = await import('./flow_loader.mjs');
   runFlowCli(cliArgv(['integration', 'entry']));
 }
@@ -154,13 +155,14 @@ async function runOnboardingBootstrap(args) {
   assertOnlyOptions(options, [
     'root-intent',
     'product-type',
+    'input-id',
     'user-input-count-total',
     'user-input-count-after-flow-start',
     'flow-start-observed'
   ]);
   const rootIntent = assertEnumOption(options, 'root-intent', ['onboarding_only']);
   const productType = assertEnumOption(options, 'product-type', ['aipay', 'webpay', 'apppay'], { required: false });
-  await startTelemetryRun(rootIntent, productType);
+  await startTelemetryRun(rootIntent, productType, options['input-id']);
   const { runOnboardingMessageCli } = await import('./onboarding_message_runner.mjs');
   const platformEntryArgs = ['platform-entry'];
   appendOptionalTerminalCountOptions(platformEntryArgs, options);

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

@@ -22,16 +22,26 @@ const terminalForegroundUploadTimeoutMs = 1200;
 const terminalForegroundUploadMaxAttempts = 2;
 const terminalForegroundUploadRetryDelayMs = 300;
 const terminalBackgroundRetryDelayMs = 1000;
+const permissionedForegroundFlushLimit = 5;
 const terminalCountArgNames = Object.freeze([
   'user-input-count-total',
   'user-input-count-after-flow-start',
   'flow-start-observed'
 ]);
+const terminalReasonValues = new Set([
+  'completed',
+  'partial_with_remaining_actions',
+  'integration_blocked',
+  'unsupported_product',
+  'unsupported_platform',
+  'enterprise_account_unsupported',
+  'unknown'
+]);
+const initialUserInputId = 'run.start';
 const outboxFlushLimit = 50;
 const outboxClaimTtlMs = 5 * 60 * 1000;
 const outboxMaxRecords = 1000;
 const outboxMaxAgeMs = 7 * 24 * 60 * 60 * 1000;
-const permissionedFlushTtlMs = 12 * 60 * 60 * 1000;
 const platformProjectIdEnvKeys = Object.freeze(['COZE_PROJECT_ID', 'MEOO_PROJECT_ID']);
 const sessionStateEnvKeys = Object.freeze([
   'CODEX_THREAD_ID',
@@ -226,21 +236,12 @@ function uploadStatusPath(env = process.env) {
   return path.join(stateDir(env), 'upload-status.json');
 }
 
-function permissionedFlushStatePath(env = process.env) {
-  if (env.ALIPAY_AIPAY_TELEMETRY_PERMISSIONED_FLUSH_STATE_FILE) {
-    return env.ALIPAY_AIPAY_TELEMETRY_PERMISSIONED_FLUSH_STATE_FILE;
-  }
-  const source = stableStateSource(env) || (Object.keys(env).length > 0 ? readRunState(env)?.run_id : '') || '';
-  return path.join(stateDir(env), `${stateKeyFromSource(source)}.permissioned-flush.json`);
-}
-
 export function telemetryStoragePaths(env = process.env) {
   return {
     state_dir: stateDir(env),
     run_state_file: runStatePath(env),
     outbox_dir: outboxDir(env),
-    upload_status_file: uploadStatusPath(env),
-    permissioned_flush_state_file: permissionedFlushStatePath(env)
+    upload_status_file: uploadStatusPath(env)
   };
 }
 
@@ -416,20 +417,45 @@ function parseBooleanFlag(value) {
   return null;
 }
 
+function normalizeTerminalReason(value) {
+  if (typeof value !== 'string' || !value) return 'unknown';
+  const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, '_');
+  return terminalReasonValues.has(normalized) ? normalized : '';
+}
+
+function normalizeUserInputId(value) {
+  if (typeof value !== 'string') return '';
+  const text = value.trim();
+  if (!text || text.length > 256 || /[\u0000-\u001f\u007f]/u.test(text)) return '';
+  return text;
+}
+
+function userInputHash(inputId, runId) {
+  const normalized = normalizeUserInputId(inputId);
+  if (!normalized || !safeRunId(runId)) return '';
+  return crypto.createHash('sha256').update(`${runId}\u0000${normalized}`).digest('hex').slice(0, 32);
+}
+
+function normalizeUserInputHashes(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.filter((entry) => typeof entry === 'string' && /^[a-f0-9]{32}$/u.test(entry)))];
+}
+
 function normalizeUserInputCounts(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return { total: 0, after_flow_start: 0, flow_start_observed: false };
+    return { total: 0, after_flow_start: 0, flow_start_observed: false, input_hashes: [] };
   }
   const total = parseNonNegativeInteger(value.total ?? value.user_input_count_total);
   const afterFlowStart = parseNonNegativeInteger(value.after_flow_start ?? value.user_input_count_after_flow_start);
   const flowStartObserved = parseBooleanFlag(value.flow_start_observed);
   if (total === null || afterFlowStart === null || flowStartObserved === null) {
-    return { total: 0, after_flow_start: 0, flow_start_observed: false };
+    return { total: 0, after_flow_start: 0, flow_start_observed: false, input_hashes: [] };
   }
   return {
     total,
     after_flow_start: Math.min(afterFlowStart, total),
     flow_start_observed: flowStartObserved,
+    input_hashes: normalizeUserInputHashes(value.input_hashes),
     flow_start_observed_at: parseNonNegativeInteger(value.flow_start_observed_at) || undefined,
     updated_at: parseNonNegativeInteger(value.updated_at) || undefined
   };
@@ -461,15 +487,51 @@ function validateTerminalCountPayload(payload = {}, env = process.env, { strict
   return { total, afterFlowStart, flowStartObserved, rootIntent };
 }
 
+function initialUserInputCounts(nowMs = Date.now(), inputId = initialUserInputId, runId = '') {
+  return {
+    total: 1,
+    after_flow_start: 0,
+    flow_start_observed: false,
+    input_hashes: [userInputHash(inputId, runId) || userInputHash(initialUserInputId, runId)].filter(Boolean),
+    updated_at: nowMs
+  };
+}
+
+function addUserInputCount(counts, phase, inputId, runId, nowMs = Date.now()) {
+  const inputHash = userInputHash(inputId, runId);
+  if (!inputHash || counts.input_hashes.includes(inputHash)) return counts;
+  return {
+    ...counts,
+    total: counts.total + 1,
+    after_flow_start: counts.after_flow_start + (phase === 'after-flow' ? 1 : 0),
+    input_hashes: [...counts.input_hashes, inputHash],
+    updated_at: nowMs
+  };
+}
+
+function publicUserInputCountState(counts) {
+  if (!counts) return null;
+  const normalized = normalizeUserInputCounts(counts);
+  return {
+    total: normalized.total,
+    after_flow_start: normalized.after_flow_start,
+    flow_start_observed: normalized.flow_start_observed,
+    tracked_inputs: normalized.input_hashes.length
+  };
+}
+
 function terminalExtInfoFromPayload(payload = {}, env = process.env) {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return '';
   const counts = validateTerminalCountPayload(payload, env);
   if (!counts) return '';
+  const terminalReason = normalizeTerminalReason(payload.terminalReason ?? payload.terminal_reason);
+  if (!terminalReason) return '';
   return JSON.stringify({
     user_input_count_total: counts.total,
     user_input_count_after_flow_start: counts.afterFlowStart,
     flow_start_observed: counts.flowStartObserved,
-    root_intent: counts.rootIntent
+    root_intent: counts.rootIntent,
+    terminal_reason: terminalReason
   });
 }
 
@@ -632,6 +694,11 @@ export function terminalMetricContextFromArgs(args, context = {}) {
     const value = args[name];
     return typeof value === 'string' && value.length > 0 ? value : undefined;
   };
+  const terminalReason = normalizeTerminalReason(
+    optional('terminal-reason') ?? context.terminalReason ?? context.terminal_reason
+  );
+  if (!terminalReason) throw new Error('--terminal-reason 不在允许枚举中');
+  const reasonContext = { terminalReason };
   const hasCountArg = terminalCountArgNames.some((name) => Object.prototype.hasOwnProperty.call(args, name));
   if (hasCountArg) {
     const missing = terminalCountArgNames.filter((name) => optional(name) === undefined);
@@ -643,14 +710,31 @@ export function terminalMetricContextFromArgs(args, context = {}) {
       rootIntent: args['root-intent'] || args.rootIntent || args.root_intent || context.rootIntent || context.root_intent
     }, process.env, { strict: true });
     return {
+      rootIntent: counts.rootIntent,
       userInputCountTotal: counts.total,
       userInputCountAfterFlowStart: counts.afterFlowStart,
-      flowStartObserved: counts.flowStartObserved
+      flowStartObserved: counts.flowStartObserved,
+      ...reasonContext
     };
   }
   const state = readRunState(process.env);
   const stored = normalizeUserInputCounts(state?.user_input_counts);
-  if (stored.total < 1) return {};
+  if (stored.total < 1) {
+    const fallbackCounts = validateTerminalCountPayload({
+      userInputCountTotal: 1,
+      userInputCountAfterFlowStart: 0,
+      flowStartObserved: Boolean(stored.flow_start_observed),
+      rootIntent: state?.root_intent
+    }, process.env);
+    if (!fallbackCounts) return {};
+    return {
+      rootIntent: fallbackCounts.rootIntent,
+      userInputCountTotal: fallbackCounts.total,
+      userInputCountAfterFlowStart: fallbackCounts.afterFlowStart,
+      flowStartObserved: fallbackCounts.flowStartObserved,
+      ...reasonContext
+    };
+  }
   const counts = validateTerminalCountPayload({
     userInputCountTotal: stored.total,
     userInputCountAfterFlowStart: stored.after_flow_start,
@@ -659,19 +743,25 @@ export function terminalMetricContextFromArgs(args, context = {}) {
   }, process.env);
   if (!counts) return {};
   return {
+    rootIntent: counts.rootIntent,
     userInputCountTotal: counts.total,
     userInputCountAfterFlowStart: counts.afterFlowStart,
-    flowStartObserved: counts.flowStartObserved
+    flowStartObserved: counts.flowStartObserved,
+    ...reasonContext
   };
 }
 
 function contextFromCliArgs(args) {
-  return {
+  const context = {
     runId: args['run-id'],
     rootIntent: args['root-intent'],
     productType: args['product-type'],
-    productName: args['product-name'],
-    ...terminalMetricContextFromArgs(args)
+    productName: args['product-name']
+  };
+  if (args._[0] !== 'run.terminal') return context;
+  return {
+    ...context,
+    ...terminalMetricContextFromArgs(args, context)
   };
 }
 
@@ -699,11 +789,42 @@ function createRunState(args, env = process.env, nowMs = Date.now()) {
     run_id: runId,
     root_intent: rootIntent,
     product_type: productType,
+    user_input_counts: initialUserInputCounts(nowMs, args['input-id'] || initialUserInputId, runId),
     created_at: nowMs,
     updated_at: nowMs
   };
 }
 
+function withInitialUserInputCount(state, nowMs = Date.now(), inputId = initialUserInputId) {
+  const counts = normalizeUserInputCounts(state?.user_input_counts);
+  if (counts.total >= 1) return state;
+  return {
+    ...state,
+    user_input_counts: initialUserInputCounts(nowMs, inputId, state.run_id),
+    updated_at: nowMs
+  };
+}
+
+function withCurrentUserInputCount(state, nowMs = Date.now(), inputId = '') {
+  const normalizedInputId = normalizeUserInputId(inputId);
+  const counts = normalizeUserInputCounts(state?.user_input_counts);
+  if (counts.total < 1) return withInitialUserInputCount(state, nowMs, normalizedInputId || initialUserInputId);
+  if (!normalizedInputId) return state;
+  const nextCounts = addUserInputCount(
+    counts,
+    counts.flow_start_observed ? 'after-flow' : 'before-flow',
+    normalizedInputId,
+    state.run_id,
+    nowMs
+  );
+  if (nextCounts === counts) return state;
+  return {
+    ...state,
+    user_input_counts: nextCounts,
+    updated_at: nowMs
+  };
+}
+
 function compatibleProductType(existingProductType, requestedProductType) {
   const existing = canonicalProductType(existingProductType) || 'UNKNOWN';
   const requested = canonicalProductType(requestedProductType) || 'UNKNOWN';
@@ -740,12 +861,12 @@ function createOrReuseRunState(args, env = process.env, nowMs = Date.now()) {
   const requestedRunId = platformProjectRunId(env) || safeRunId(args['run-id']);
   const existing = readRunState(env);
   if (reusableRunState(existing, rootIntent, requestedProductType) && (!requestedRunId || existing.run_id === requestedRunId)) {
-    return {
+    return withCurrentUserInputCount({
       ...existing,
       root_intent: rootIntent,
       product_type: mergeProductType(existing.product_type, requestedProductType),
       updated_at: nowMs
-    };
+    }, nowMs, args['input-id']);
   }
   return createRunState(args, env, nowMs);
 }
@@ -803,25 +924,26 @@ export function markTelemetryFlowStart(env = process.env, nowMs = Date.now()) {
   return next.user_input_counts;
 }
 
-export function recordTelemetryUserInput(phase, env = process.env, nowMs = Date.now()) {
+export function recordTelemetryUserInput(phase, env = process.env, nowMs = Date.now(), inputId = '') {
   if (!telemetryEnabled(env)) return null;
   if (!['before-flow', 'after-flow'].includes(phase)) {
     throw new Error('--phase 仅支持 before-flow、after-flow');
   }
+  const normalizedInputId = normalizeUserInputId(inputId);
+  if (!normalizedInputId) throw new Error('用户输入计数必须提供本地幂等 --input-id，且不得包含用户输入原文或敏感信息');
   const existing = readRunState(env);
   if (!existing?.run_id || existing.terminal) return null;
   const counts = normalizeUserInputCounts(existing.user_input_counts);
   if (phase === 'before-flow' && counts.flow_start_observed) {
     throw new Error('当前 run 已观测 flow start，后续用户输入必须记录为 after-flow');
   }
-  const nextCounts = {
-    ...counts,
-    total: counts.total + 1,
-    after_flow_start: counts.after_flow_start + (phase === 'after-flow' ? 1 : 0),
-    flow_start_observed: counts.flow_start_observed || phase === 'after-flow',
-    updated_at: nowMs
-  };
-  if (phase === 'after-flow' && !counts.flow_start_observed) nextCounts.flow_start_observed_at = nowMs;
+  if (phase === 'after-flow' && !counts.flow_start_observed) {
+    throw new Error('当前 run 尚未观测 flow start，不能记录 after-flow 用户输入');
+  }
+  const inputHash = userInputHash(normalizedInputId, existing.run_id);
+  if (!inputHash) throw new Error('用户输入计数 input-id 无法生成本地幂等键');
+  if (counts.input_hashes.includes(inputHash)) return counts;
+  const nextCounts = addUserInputCount(counts, phase, normalizedInputId, existing.run_id, nowMs);
   const next = {
     ...existing,
     user_input_counts: nextCounts,
@@ -831,6 +953,14 @@ export function recordTelemetryUserInput(phase, env = process.env, nowMs = Date.
   return nextCounts;
 }
 
+export function recordTelemetryUserInputForCurrentPhase(inputId, env = process.env, nowMs = Date.now()) {
+  if (!telemetryEnabled(env)) return null;
+  const existing = readRunState(env);
+  if (!existing?.run_id || existing.terminal) return null;
+  const counts = normalizeUserInputCounts(existing.user_input_counts);
+  return recordTelemetryUserInput(counts.flow_start_observed ? 'after-flow' : 'before-flow', env, nowMs, inputId);
+}
+
 function updateExistingRunStateFromEvent(event, env = process.env) {
   const existing = readRunState(env);
   if (!existing) return false;
@@ -1280,22 +1410,6 @@ function readUploadStatus(env = process.env) {
   }
 }
 
-function readPermissionedFlushState(env = process.env, nowMs = Date.now()) {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(permissionedFlushStatePath(env), 'utf8'));
-    if (!parsed || parsed.schema_ver !== 1) return null;
-    const requestedAt = Number(parsed.requested_at || 0);
-    if (!Number.isFinite(requestedAt) || nowMs - requestedAt > permissionedFlushTtlMs) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-
-function writePermissionedFlushState(state, env = process.env) {
-  return writePrivateJson(permissionedFlushStatePath(env), { schema_ver: 1, ...state });
-}
-
 function networkUploadFailure(status) {
   const errorCode = safeDimension(status?.error_code || '', '', 80).toUpperCase();
   if (permissionedFlushNetworkErrors.has(errorCode)) return errorCode;
@@ -1309,49 +1423,41 @@ function networkUploadFailure(status) {
   return '';
 }
 
-export function permissionedFlushDecision(env = process.env, nowMs = Date.now(), { markRequested = false } = {}) {
+export function permissionedFlushDecision(env = process.env) {
   const outboxCount = outboxFiles(env).length;
   const status = readUploadStatus(env);
   const errorCode = networkUploadFailure(status);
-  const existing = readPermissionedFlushState(env, nowMs);
-  const alreadyRequested = Boolean(existing);
   const result = {
     needed: false,
     outbox_count: outboxCount,
-    already_requested: alreadyRequested,
     error_code: errorCode || safeDimension(status?.error_code || '', '', 80),
     status: safeDimension(status?.status || 'unknown', 'unknown', 80)
   };
   if (!telemetryUploadEnabled(env) || outboxCount <= 0 || !errorCode) {
     return result;
   }
-  if (alreadyRequested) {
-    return {
-      ...result,
-      requested_at: existing.requested_at
-    };
-  }
   result.needed = true;
-  if (markRequested) {
-    writePermissionedFlushState({
-      requested_at: nowMs,
-      error_code: errorCode,
-      outbox_count: outboxCount
-    }, env);
-    result.requested_at = nowMs;
-  }
   return result;
 }
 
+function emitPermissionedFlushNeededMarkers(env = process.env, stream = process.stderr) {
+  const decision = permissionedFlushDecision(env);
+  if (!decision.needed || !stream || typeof stream.write !== 'function') return false;
+  stream.write(`${internalPrefix}PERMISSIONED_FLUSH_DECISION=${JSON.stringify(decision)}\n`);
+  stream.write(`${internalPrefix}PERMISSIONED_FLUSH_NEEDED=true\n`);
+  return true;
+}
+
 export async function flushOutbox(env = process.env, {
   limit = outboxFlushLimit,
   targetFile = '',
   timeoutMs = uploadTimeoutMs,
-  sender = sendSyncLogReportDetailed
+  sender = sendSyncLogReportDetailed,
+  prioritizeTerminal = false
 } = {}) {
   const result = { attempted: 0, sent: 0, retained: 0, invalid: 0 };
   if (!telemetryUploadEnabled(env)) return result;
-  const files = outboxFiles(env, { targetFile, limit });
+  const files = outboxFilesForFlush(env, { targetFile, limit, prioritizeTerminal });
   for (const file of files) {
     const claimedFile = claimOutboxFile(file);
     if (!claimedFile) continue;
@@ -1413,6 +1519,26 @@ export async function flushOutbox(env = process.env, {
   return result;
 }
 
+function outboxFilesForFlush(env = process.env, { targetFile = '', limit = 0, prioritizeTerminal = false } = {}) {
+  const files = outboxFiles(env, { targetFile, limit: prioritizeTerminal ? 0 : limit });
+  const ordered = prioritizeTerminal ? prioritizeTerminalOutboxFiles(files) : files;
+  return limit > 0 ? ordered.slice(0, limit) : ordered;
+}
+
+function prioritizeTerminalOutboxFiles(files) {
+  return files
+    .map((file, index) => {
+      const record = readOutboxRecord(file);
+      const stage = record?.event?.stage || record?.report?.item?.c2 || '';
+      return { file, index, terminal: stage === 'run.terminal' };
+    })
+    .sort((left, right) => {
+      if (left.terminal !== right.terminal) return left.terminal ? -1 : 1;
+      return left.index - right.index;
+    })
+    .map((entry) => entry.file);
+}
+
 function spawnOutboxFlush(env = process.env, { delayMs = 0 } = {}) {
   if (!telemetryUploadEnabled(env)) return false;
   try {
@@ -1445,6 +1571,34 @@ function spawnOutboxFlush(env = process.env, { delayMs = 0 } = {}) {
   }
 }
 
+function permissionedForegroundFlushLimitFromEnv(env = process.env) {
+  const parsed = parseNonNegativeInteger(env.ALIPAY_AIPAY_TELEMETRY_PERMISSIONED_FLUSH_LIMIT);
+  return parsed && parsed > 0 ? Math.min(parsed, outboxFlushLimit) : permissionedForegroundFlushLimit;
+}
+
+export async function runPermissionedOutboxFlush(env = process.env, {
+  limit = permissionedForegroundFlushLimitFromEnv(env),
+  timeoutMs = uploadTimeoutMs,
+  sender = sendSyncLogReportDetailed,
+  spawnBackground = false
+} = {}) {
+  const flush = await flushOutbox(env, {
+    limit,
+    timeoutMs,
+    sender,
+    prioritizeTerminal: true
+  });
+  const backgroundRetry = spawnBackground
+    && flush.attempted > 0
+    && outboxFiles(env).length > 0
+    ? spawnOutboxFlush(env, { delayMs: terminalBackgroundRetryDelayMs })
+    : false;
+  return {
+    flush,
+    background_retry: backgroundRetry
+  };
+}
+
 function foregroundFlushTerminalOutboxFile(file, env = process.env) {
   if (!telemetryUploadEnabled(env) || !file) return false;
   const parsed = parseNonNegativeInteger(env.ALIPAY_AIPAY_TELEMETRY_TERMINAL_FLUSH_TIMEOUT_MS);
@@ -1487,8 +1641,13 @@ function scheduleSyncLogUpload(event, env = process.env) {
     return false;
   }
   if (event?.stage === 'run.terminal') {
-    if (!foregroundFlushTerminalOutboxFile(queuedFile, env)) {
+    if (foregroundFlushTerminalOutboxFile(queuedFile, env)) {
+      if (outboxFiles(env).length > 0) {
+        spawnOutboxFlush(env, { delayMs: terminalBackgroundRetryDelayMs });
+      }
+    } else {
       spawnOutboxFlush(env, { delayMs: terminalBackgroundRetryDelayMs });
+      emitPermissionedFlushNeededMarkers(env);
     }
     return true;
   }
@@ -1507,7 +1666,7 @@ export async function runTelemetryCli(argv = process.argv) {
   try {
     const { command, args } = parseCliArgs(argv);
     if (command === 'start-run') {
-      assertCliArgs(args, new Set(['root-intent', 'product-type', 'run-id']), 0);
+      assertCliArgs(args, new Set(['root-intent', 'product-type', 'run-id', 'input-id']), 0);
       const state = createOrReuseRunState(args);
       if (!writeRunState(state) && telemetryEnabled(process.env)) {
         recordLocalTelemetryFailure('LOCAL_RUN_STATE_WRITE_FAILED', 'failed to write local telemetry run state');
@@ -1533,10 +1692,10 @@ export async function runTelemetryCli(argv = process.argv) {
       return 0;
     }
     if (command === 'count-user-input' && args._.length === 0) {
-      assertCliArgs(args, new Set(['phase']), 0);
-      const counts = recordTelemetryUserInput(args.phase, process.env, Date.now());
+      assertCliArgs(args, new Set(['phase', 'input-id']), 0);
+      const counts = recordTelemetryUserInput(args.phase, process.env, Date.now(), args['input-id']);
       if (counts) {
-        process.stderr.write(`${internalPrefix}USER_INPUT_COUNT_STATE=${JSON.stringify(counts)}\n`);
+        process.stderr.write(`${internalPrefix}USER_INPUT_COUNT_STATE=${JSON.stringify(publicUserInputCountState(counts))}\n`);
       } else {
         process.stderr.write(`${internalPrefix}USER_INPUT_COUNT_STATE_MISSING=true\n`);
       }
@@ -1546,7 +1705,7 @@ export async function runTelemetryCli(argv = process.argv) {
       assertCliArgs(args, new Set(), 0);
       const counts = markTelemetryFlowStart(process.env, Date.now());
       if (counts) {
-        process.stderr.write(`${internalPrefix}USER_INPUT_FLOW_START_STATE=${JSON.stringify(counts)}\n`);
+        process.stderr.write(`${internalPrefix}USER_INPUT_FLOW_START_STATE=${JSON.stringify(publicUserInputCountState(counts))}\n`);
       } else {
         process.stderr.write(`${internalPrefix}USER_INPUT_FLOW_START_STATE_MISSING=true\n`);
       }
@@ -1560,7 +1719,7 @@ export async function runTelemetryCli(argv = process.argv) {
     }
     if (command === 'permissioned-flush-status' && args._.length === 0) {
       assertCliArgs(args, new Set(), 0);
-      const decision = permissionedFlushDecision(process.env, Date.now(), { markRequested: false });
+      const decision = permissionedFlushDecision(process.env);
       process.stderr.write(`${internalPrefix}PERMISSIONED_FLUSH_STATUS=${JSON.stringify(decision)}\n`);
       if (decision.needed) {
         process.stderr.write(`${internalPrefix}PERMISSIONED_FLUSH_CANDIDATE=true\n`);
@@ -1569,17 +1728,15 @@ export async function runTelemetryCli(argv = process.argv) {
     }
     if (command === 'permissioned-flush-needed' && args._.length === 0) {
       assertCliArgs(args, new Set(), 0);
-      const decision = permissionedFlushDecision(process.env, Date.now(), { markRequested: true });
+      const decision = permissionedFlushDecision(process.env);
       process.stderr.write(`${internalPrefix}PERMISSIONED_FLUSH_DECISION=${JSON.stringify(decision)}\n`);
-      if (decision.needed) {
-        process.stderr.write(`${internalPrefix}PERMISSIONED_FLUSH_NEEDED=true\n`);
-      }
+      if (decision.needed) process.stderr.write(`${internalPrefix}PERMISSIONED_FLUSH_NEEDED=true\n`);
       return 0;
     }
     if (command === 'flush-outbox') {
       assertCliArgs(args, new Set(), 0);
       if (!telemetryEnabled(process.env)) return 0;
-      spawnOutboxFlush(process.env);
+      await runPermissionedOutboxFlush(process.env, { spawnBackground: true });
       return 0;
     }
     if (command === 'flush-outbox-worker') {
@@ -1604,6 +1761,7 @@ export async function runTelemetryCli(argv = process.argv) {
       'root-intent',
       'product-type',
       'product-name',
+      'terminal-reason',
       'timestamp-ms',
       'user-input-count-total',
       'user-input-count-after-flow-start',

package/skill/references/normal/telemetry.md

@@ -1,4 +1,4 @@
-- 测试白名单：stage/flow、产品、根意图、时间戳、Skill 版本、宿主/模型、匿名机器哈希、`run_id`、终态计数；禁密钥/账号密码/订单/交易号/截图/凭证/用户输入/路径/URL/响应/命令输出/堆栈原文；失败不影响业务，内部行 `ALIPAY_AIPAY_INTERNAL:`。
+- 字段白名单：stage/flow、产品、根意图、时间戳、Skill 版本、宿主/模型、匿名机器哈希、`run_id`、终态计数和终态原因枚举；禁密钥/账号密码/订单/交易号/截图/凭证/用户输入/路径/URL/响应/命令输出/堆栈原文；失败不影响业务，内部行 `ALIPAY_AIPAY_INTERNAL:`。
 - run：`start-run` 创建/复用 `run_id`，脚本继承 `PLATFORM_ID=<run_id>`；`root_intent + product_type` 判定复用/新建，`UNKNOWN` 补全产品仍复用同一 `run_id`；换产品/根意图/已终态/重新开始/重新走流程/作废本轮流程才新建。`COZE_PROJECT_ID`、`MEOO_PROJECT_ID`、`VITE_APP_ID`/`PLATFORM_ID` 优先；`current-run-id` 只查看，不新建 run。outbox 2xx 才删；维护/测试/Benchmark 禁上传。
-- 计数：每条用户输入到达当前 run 后立刻执行 `telemetry count-user-input --phase before-flow|after-flow` 写本地 run state，不联网；触发 run 的首条消息计 before-flow。`user_input_count_total` 自触发 run 用户消息起；`user_input_count_after_flow_start` 自方案送达并进入正式执行后的下一条用户消息起。产品/MCC 澄清或选择、项目/语言/框架补齐、项目候选和方案本身只计 total；`full_process` 不因 Onboarding 重置。`flow_start_observed`=正式 flow start，由 `integration.user_confirmed|onboarding.user_confirmed` 自动标记；用户 kill 未终态不补报。closeout 默认派生本地计数，状态不可用且已核对时才显式传三项；runner 拒绝缺项、负数、`after > total`、已观测 flow start 但 `after >= total`。终态只追加计数，不新增确认点、stage 或独立上报。`run.terminal` 入队后以短超时前台 drain，仅当前 terminal 文件，避免流程最后的 detached worker 被宿主回收；若文件仍在且是网络类错误，短重试一次并挂延迟后台补传，不申请额外权限；失败保留 outbox。`c4=ext_info`，计数合法且有 `root_intent` 才写 JSON。
-- 补传：不为权限探测新增网络事件；实际低敏上传就是自然探测，宿主已允许访问 collector 时不额外申请权限。`upload-status`/`permissioned-flush-status` 不联网、不消耗请求窗口；后者在最近 `ENOTFOUND|EAI_AGAIN|ETIMEDOUT`、outbox 积压、12h 未请求时出 `PERMISSIONED_FLUSH_CANDIDATE=true`，再执行 `permissioned-flush-needed` 预占；唯一 `PERMISSIONED_FLUSH_NEEDED=true` 时才申请。`flush-outbox` 后台补传：POST 到 `collect.alipay.com:443`，路径 `/yuyan/`。说明：`是否允许 Agent 上报 Skill 使用过程的统计信息？只含产品类别、时间、Skill 版本、匿名设备标识、人机交互次数等用于帮助改善用户体验的非敏感信息，不会采集包含源代码、用户输入内容等任何敏感信息。` 同一 Agent 会话只请求一次；无宿主标识时按当前 `run_id` 隔离 12h；拒绝/失败/非2xx留 outbox；collector 结果非业务条件；无 `inspect-outbox`、`--confirm-reviewed`、`alipay-cli whoami` 兜底。
+- 计数：统计窗口从首次触发本 Skill 的用户消息开始，到当前 `run_id` 的 `run.terminal` 事件生成为止。只计用户在 Agent 对话框发送的消息，不计宿主权限弹窗、系统授权、网页授权、扫码、Skill stage、runner、工具调用或自动轮询；文字、图片/文件上传、空白或短确认消息、材料补充、确认回复和中途插话都按一条用户消息计，同一条消息同时包含文字和图片/文件时仍只计一条。`USER_INPUT_ID` 由 Agent 从首次触发本 Skill 的用户消息开始，在当前对话内给每条新用户消息分配单调序号，同一消息重试复用同一值；禁止包含或派生自用户输入内容、文件名、路径、截图/OCR、业务材料、stage 名或工具调用序号，运行时只保存本地 hash 且不上报。`start-run --input-id "$USER_INPUT_ID"` 自动把触发当前 run 的首条用户输入计为 `before-flow`；若中断/压缩后用新的 `USER_INPUT_ID` 重复进入同一未终态 run，`start-run` 会按当前 phase 幂等补计该用户消息。`reply confirm --reply "$USER_REPLY" --input-id "$USER_INPUT_ID"` 和 onboarding recovery 自动按当前 phase 幂等计数，禁止再为同一条回复手动执行 `count-user-input`。其他用户输入到达当前 run 后，包括用户中途打断、补充材料、只上传图片/文件或只问问题，在继续任何 Skill 动作或对该输入作业务答复前立刻执行 `telemetry count-user-input --phase before-flow|after-flow --input-id "$USER_INPUT_ID"` 写本地 run state，不联网；重复同一 `USER_INPUT_ID` 不加计。`user_input_count_total` 自触发 run 用户消息起；`user_input_count_after_flow_start` 自方案送达并进入正式执行后的下一条用户消息起。产品/MCC 澄清或选择、项目/语言/框架补齐、项目候选和方案本身只计 total；`full_process` 不因 Onboarding 重置。`flow_start_observed`=正式 flow start，由 `integration.user_confirmed|onboarding.user_confirmed` 自动标记但不计数；flow start 前拒绝 `after-flow`，用户 kill 未终态不补报。closeout 默认派生本地计数；状态为空时终态使用首条输入的最小合法计数，状态不可用且已核对时才显式传三项；runner 拒绝缺项、负数、`after > total`、已观测 flow start 但 `after >= total`。`terminal_reason` 只允许 `completed|partial_with_remaining_actions|integration_blocked|unsupported_product|unsupported_platform|enterprise_account_unsupported|unknown`，由终态 runner 依据机器事实派生，禁止自由文本原因。终态只追加计数和原因枚举，不新增确认点、stage 或独立上报。`run.terminal` 入队后以短超时前台 drain，仅当前 terminal 文件，避免流程最后的 detached worker 被宿主回收；当前 terminal 文件成功发送但仍有历史 outbox 积压时挂延迟后台补传；若文件仍在且是网络类错误，短重试一次并挂延迟后台补传，同时输出内部 `PERMISSIONED_FLUSH_NEEDED=true` 供 Agent 当场进入通用补传路径；失败保留 outbox。`c4=ext_info`，计数合法且有 `root_intent` 才写 JSON。
+- 补传：不为权限探测新增网络事件；实际低敏上传就是自然探测，宿主已允许访问 collector 时不额外申请权限。任一 telemetry 上传若因 DNS、连接或超时失败导致 outbox 积压，均使用同一套本地判断和补传机制。`upload-status`/`permissioned-flush-status`/`permissioned-flush-needed` 都不联网、不写请求窗口或抑制状态；只要最近错误是 `ENOTFOUND|EAI_AGAIN|ETIMEDOUT` 等 DNS/连接/超时类错误且 outbox 仍有积压，`permissioned-flush-status` 出 `PERMISSIONED_FLUSH_CANDIDATE=true`，`permissioned-flush-needed` 出唯一 `PERMISSIONED_FLUSH_NEEDED=true` 后才按需申请补传权限。`flush-outbox` 前台完成一次有界小批量补传，优先发送积压的 `run.terminal`，再处理其他 outbox；失败、非 2xx 或仍有剩余积压时继续保留 outbox，失败后仍按实时条件继续允许补传，并可挂一个延迟后台 worker 作兜底。目标限定为 POST `collect.alipay.com:443` 的 `/yuyan/` 路径。说明：`是否允许 Agent 上报 Skill 使用过程的统计信息？只含产品类别、时间、Skill 版本、匿名设备标识、人机交互次数等用于帮助改善用户体验的非敏感信息，不会采集包含源代码、用户输入内容等任何敏感信息。` collector 结果非业务条件；无 `inspect-outbox`、`--confirm-reviewed`、`alipay-cli whoami` 兜底。

package/skill/references/onboarding/flow.md

@@ -56,7 +56,7 @@ Step 1: 方案规划 → Step 2: 环境检查 → Step 3: 登录授权
 <!-- GENERATED:ONBOARDING-GUARDS-SHARED:START -->
 共享护栏：`P-MCP-CONTRACT-FROZEN` 仅用已验证脚本；禁推断或尝试近似方法；`P-AUTH-BEFORE-ONBOARDING` 登录/scope/MCC 未通过前禁查询和写入；`P-SENSITIVE-STATE` 公钥限当前 app 调用且禁复述/保存；敏感值禁入回复/摘要/日志/状态/宽权限文件；临时 URL 仅由登记动作展示；`P-CUSTOMER-OUTPUT-EXCLUSIVE` 登记 stdout 原文是唯一正文；阻塞送达后立即等待；`P-ONBOARDING-CONTROL-CHANNEL` 内部行禁对客；正文为空按唯一终态转移；`P-DETERMINISTIC-HANDOFF` 仅执行登记命令并按唯一终态转移；禁追加解析；失败只走登记恢复。
 <!-- GENERATED:ONBOARDING-GUARDS-SHARED:END -->
-环境检查、产品/MCC 澄清或方案展示前先执行平台入口。`onboarding_only` 正常由 `onboarding-bootstrap --root-intent onboarding_only` 包含本动作和 entry 加载；仅原子 fallback 或 `full_process` 衔接时执行：
+环境检查、产品/MCC 澄清或方案展示前先执行平台入口。`onboarding_only` 正常由 `onboarding-bootstrap --root-intent onboarding_only --input-id "$USER_INPUT_ID"` 包含本动作和 entry 加载；仅原子 fallback 或 `full_process` 衔接时执行：
 
 ```bash
 node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-message platform-entry
@@ -191,7 +191,7 @@ Step 1 的产品/MCC 唯一事实校验和方案送达、Step 2 的环境 READY
    ├─ AUTH_FLOW:RETRY_WITH_LOCAL_FS_PERMISSION → 保留当前授权页短时状态，取得 CLI 私有状态目录权限后原样重试当前 wait 命令一次
    ├─ AUTH_FLOW:FAILED → 停止并按错误输出恢复，禁止进入 Step 3.1
    └─ AUTH_FLOW:SCOPE_MISMATCH / MCC_MISMATCH → 执行第 4 项
-3. 仅 PENDING 后把用户原始回复传给 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-recovery auth-confirm --reply "$USER_REPLY" --scope "$SCOPE" --sales-code "$SALES_CODE" --mcc-code "$MCC_CODE" --product-name "$PRODUCT_NAME" --mcc-name "$MCC_NAME"`；runner 复用统一肯定语义判定（包括 `1`、“继续”“好了”“已完成”“OK”等），接受后只执行一次原 `auth.sh confirm`。否定、疑问、取消、修改意见或含糊输入返回内部拒绝且不得查询；成功后的转移同第 2 项，PENDING 继续等待且不重启轮询
+3. 仅 PENDING 后把用户原始回复传给 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-recovery auth-confirm --reply "$USER_REPLY" --input-id "$USER_INPUT_ID" --scope "$SCOPE" --sales-code "$SALES_CODE" --mcc-code "$MCC_CODE" --product-name "$PRODUCT_NAME" --mcc-name "$MCC_NAME"`；runner 复用统一肯定语义判定（包括 `1`、“继续”“好了”“已完成”“OK”等）并按当前用户消息幂等计数，接受后只执行一次原 `auth.sh confirm`。否定、疑问、取消、修改意见或含糊输入返回内部拒绝且不得查询；成功后的转移同第 2 项，PENDING 继续等待且不重启轮询
 4. node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" auth mismatch --defer-open --scope "$SCOPE" --sales-code "$SALES_CODE" --mcc-code "$MCC_CODE" --product-name "$PRODUCT_NAME" --mcc-name "$MCC_NAME"
    ├─ AUTH_FLOW:READY_TO_OPEN → 输出非阻塞授权页并按第 2 项执行 open + wait
    ├─ AUTH_FLOW:CONTEXT_MISMATCH → 未执行 logout；使用当前已确认的完整参数重新执行第 1 项
@@ -446,8 +446,8 @@ node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" app open-key-page "<app
 node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" app verify-key-and-audit --product-type "$PRODUCT_TYPE" "<本轮create输出的appId>" "<同一publicKey>"
 node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" app verify-key --product-type "$PRODUCT_TYPE" "<appId>" "<同一publicKey>"
 # 仅轮询耗尽且用户明确已完成；单查一次
-node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-recovery application-key --reply "$USER_REPLY" --product-type "$PRODUCT_TYPE" --mode verify-key-and-audit --app-id "<本轮create输出的appId>" --public-key "<同一publicKey>"
-node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-recovery application-key --reply "$USER_REPLY" --product-type "$PRODUCT_TYPE" --mode verify-key --app-id "<appId>" --public-key "<同一publicKey>"
+node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-recovery application-key --reply "$USER_REPLY" --input-id "$USER_INPUT_ID" --product-type "$PRODUCT_TYPE" --mode verify-key-and-audit --app-id "<本轮create输出的appId>" --public-key "<同一publicKey>"
+node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-recovery application-key --reply "$USER_REPLY" --input-id "$USER_INPUT_ID" --product-type "$PRODUCT_TYPE" --mode verify-key --app-id "<appId>" --public-key "<同一publicKey>"
 node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" app audit --product-type "$PRODUCT_TYPE" "<appId>"
 ```
 

package/skill/references/onboarding/modules/authorization.md

@@ -32,7 +32,7 @@ CLI `login --complete` 成功只表示页面侧确认完成，不代表本机已
 
 授权页只允许 `https://aipay.alipay.com/cli-auth`，必含唯一 `deviceCode/productCode/mccCode`，只允许可选 `platform`；禁止 CLI `verification_url`、额外参数、重复参数和 fragment。页面 stdout 必须先作为独立对客消息送达，再执行 `auth.sh open` 和 `auth.sh wait`，后续 pending 或收口不得合并进同一回复。
 
-`wait` 生产最多查询 12 次，未成功的相邻查询间隔 5 秒，成功或过期立即停止。耗尽后把用户原始回复交给统一 runtime 的 `onboarding-recovery auth-confirm`；runner 复用统一肯定语义判定器，接受 `继续`、`好了`、`已完成`、`确认`、`OK` 和兼容输入 `1`，每次接受只执行一次 `auth.sh confirm`，不重启自动轮询。否定、疑问、取消、修改意见或含糊输入不查询。
+`wait` 生产最多查询 12 次，未成功的相邻查询间隔 5 秒，成功或过期立即停止。耗尽后按 flow 登记命令把用户原始回复和当前 `USER_INPUT_ID` 交给统一 runtime 的 `onboarding-recovery auth-confirm`；runner 复用统一肯定语义判定器并对该用户消息幂等计数，接受 `继续`、`好了`、`已完成`、`确认`、`OK` 和兼容输入 `1`，每次接受只执行一次 `auth.sh confirm`，不重启自动轮询。否定、疑问、取消、修改意见或含糊输入不查询。
 
 授权对客正文只由 `auth.sh` 调用消息目录生成。初始页面不得提前要求回复完成；pending 的自然语言提示、允许回复和授权页返回提示都不在本模块维护副本。
 

package/skill/references/runtime-entry.md

@@ -30,7 +30,7 @@ node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" render <messageId> --va
 
 动态 JSON 只取本轮事实；无变量传 `{}`，禁止字符串替换或 `eval`。正常路径禁止预跑 `render --schema` 或用 `jq`/消息目录探测字段。renderer 返回 `MESSAGE_RENDER_ERROR` 时必须先复查同一 `messageId` + `variant` schema，禁止猜枚举；非 0 即停止，不手写兜底。
 
-阻塞点展示登记摘要后，把用户原始回复交给 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" reply confirm --reply "$USER_REPLY"`；仅唯一 `ALIPAY_AIPAY_INTERNAL:REPLY_DECISION=CONFIRMED` 可推进。`1`、`继续/继续推进`、`好了/已完成`、`确认/确定/同意`、`OK` 等明确肯定表达等价；否定、疑问、取消、修改或含糊回复不确认。确认只绑定当前产品、项目、主体、候选和摘要，任一变化即失效；此校验不新增操作点。
+阻塞点展示登记摘要后，把用户原始回复交给 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" reply confirm --reply "$USER_REPLY" --input-id "$USER_INPUT_ID"`；仅唯一 `ALIPAY_AIPAY_INTERNAL:REPLY_DECISION=CONFIRMED` 可推进。`1`、`继续/继续推进`、`好了/已完成`、`确认/确定/同意`、`OK` 等明确肯定表达等价；否定、疑问、取消、修改或含糊回复不确认。确认只绑定当前产品、项目、主体、候选和摘要，任一变化即失效；此校验不新增操作点。
 
 `<SKILL_DIR>` 是启动器确定的当前 Skill 规范化绝对路径占位符，不是 shell 变量。Skill 自有受控 Node、Shell 和 Python 入口必须使用文档登记的 `<SKILL_DIR>/references/...` 绝对路径单命令执行，禁止前置 `cd`、拼 `&&`、管道或退回相对路径；这些入口不新增权限确认或业务操作点。未登记命令和用户项目命令仍使用所在 Markdown 目录或已确认项目根，不得借用 Skill 权限。
 
@@ -40,15 +40,19 @@ node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" render <messageId> --va
 
 | 意图 | 判定 | 入口 | 后续按需加载 |
 |---|---|---|---|
-| `integration_only` | 只要求代码开发、支付集成或集成排障，未同时要求产品开通 | 执行 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" integration-bootstrap --root-intent integration_only` | 当前阶段、产品和语言的契约、示例与脚本 |
-| `onboarding_only` | 只要求签约、入驻或产品开通，未同时要求代码开发 | 执行 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-bootstrap --root-intent onboarding_only` | 当前阶段的授权、查询或写分支模块 |
+| `integration_only` | 只要求代码开发、支付集成或集成排障，未同时要求产品开通 | 执行 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" integration-bootstrap --root-intent integration_only --input-id "$USER_INPUT_ID"` | 当前阶段、产品和语言的契约、示例与脚本 |
+| `onboarding_only` | 只要求签约、入驻或产品开通，未同时要求代码开发 | 执行 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-bootstrap --root-intent onboarding_only --input-id "$USER_INPUT_ID"` | 当前阶段的授权、查询或写分支模块 |
 | `full_process` | 明确要求完整接入、一站式，或同一请求同时要求代码开发和产品开通 | `normal/full-process-routing.md` | 先 Integration，满足衔接条件后 Onboarding |
 
 `integration_only` 的 `integration-bootstrap` 只在同一 Node 进程串行执行 `telemetry start-run` 与 `flow integration entry`。`onboarding_only` 的 `onboarding-bootstrap` 只串行执行 `telemetry start-run`、`onboarding-message platform-entry` 与 `flow onboarding entry`。两者均为既有无业务写入动作，执行后不得重复原子命令。Windows 引导渲染即终结 run 并停止，`platform_id` 取本次 `run_id` 且禁止 Agent 传入；非 Windows 返回 entry 契约。`full_process` 不使用 `integration-bootstrap`；衔接 Onboarding 也不使用带 `start-run` 的 bootstrap，仍执行 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" onboarding-message platform-entry` 后按需加载 entry，避免重复 `run.intent_detected`。
 
-`full_process` 识别根意图后立即执行 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" telemetry start-run --root-intent full_process`；产品已唯一确定时追加 `--product-type <aipay|webpay|apppay>`。`integration_only` 和 `onboarding_only` 已由上表各自 bootstrap 包含同一次 `start-run`，不得重复执行本条 telemetry。命令创建/复用当前流程 `run_id`，并在遥测开启时记录 `run.intent_detected`：同一意图和产品继续复用，`UNKNOWN` 补全产品仍复用同一 `run_id`；明确换产品、换根意图或既有 run 已终态才重建。第三方平台项目 ID 仍优先固定为 `run_id`，不得被显式 run ID 或本地生成值覆盖。业务 stage 只由登记 runner/script 异步记录。
+`full_process` 识别根意图后立即执行 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" telemetry start-run --root-intent full_process --input-id "$USER_INPUT_ID"`；产品已唯一确定时追加 `--product-type <aipay|webpay|apppay>`。`integration_only` 和 `onboarding_only` 已由上表各自 bootstrap 包含同一次 `start-run`，不得重复执行本条 telemetry。命令创建/复用当前流程 `run_id`，并在遥测开启时记录 `run.intent_detected`：同一意图和产品继续复用，`UNKNOWN` 补全产品仍复用同一 `run_id`；明确换产品、换根意图或既有 run 已终态才重建。第三方平台项目 ID 仍优先固定为 `run_id`，不得被显式 run ID 或本地生成值覆盖。业务 stage 只由登记 runner/script 异步记录。
 
-遥测默认开启，`ALIPAY_AIPAY_TELEMETRY=0|false|off|no` 关闭事件/outbox/上传/flush；私有 run context 仍供 `PLATFORM_ID` 与终态生命周期。失败静默，不改变业务/消息/确认，stdout 空且 stderr 内部行不对客。`integration_only` 由 checklist 终结；Onboarding 由 closeout 或登记提前终止消息终结。上报权限不新增专门网络探针，首次 `start-run` 及后续 stage 的实际低敏上传就是自然探测；宿主已允许访问 collector 时不额外申请权限，仅 `normal/telemetry.md` 的不联网状态命令确认网络失败和 outbox 积压后，才允许一次补传权限申请。Agent 按 `normal/telemetry.md` 在每条用户输入到达时即时记录本轮计数：flow start 前执行 `telemetry count-user-input --phase before-flow`，`*.user_confirmed` 由 flow loader 自动标记起点，之后执行 `--phase after-flow`；closeout 默认从本地 run state 派生计数，状态不可用且已核对时才显式传三项计数参数，runner 拒绝缺项、负数、`after > total`、已观测 flow start 但 `after >= total` 等明显错误。不新增业务确认点或独立上报；入队后当前 `run.terminal` 文件做短超时前台 drain，失败仍保留 outbox 且不影响业务收口，网络类失败按维护文档短重试/后台兜底。after-flow 以方案后 `*.user_confirmed` 为起点；前置澄清和候选不计。脚本以当前 `run_id` 为 `PLATFORM_ID`，Agent 不手写环境前缀或改 MCP payload；维护诊断、outbox、上传和 flush 细节只在 `normal/telemetry.md` 按需读取。
+遥测默认开启，`ALIPAY_AIPAY_TELEMETRY=0|false|off|no` 关闭事件/outbox/上传/flush；私有 run context 仍供 `PLATFORM_ID` 与终态生命周期。失败静默，不改变业务/消息/确认，stdout 空且 stderr 内部行不对客。`integration_only` 由 checklist 终结；Onboarding 由 closeout 或登记提前终止消息终结。上报权限不新增网络探针；实际低敏上传就是自然探测，collector 可达时不申请。任一终态后若 telemetry outbox 因 DNS、连接或超时失败积压，按 `normal/telemetry.md` 先本地状态判断，确实需要时按需申请补传权限；`flush-outbox` 前台小批量补传并优先发送 `run.terminal`，失败仍不影响业务收口。
+
+用户输入计数是入口前置职责，统计窗口从首次触发本 Skill 的用户消息开始，到当前 `run_id` 的 `run.terminal` 事件生成为止。只计用户在 Agent 对话框发送的消息，不计宿主/系统/网页授权、扫码、Skill stage、runner、工具调用或自动轮询。文字、图片/文件、空白/短确认、材料补充、确认回复和中途插话都按一条用户消息计；同一条消息含文字和图片/文件仍只计一条。`USER_INPUT_ID` 是当前用户消息的本地幂等键：Agent 从首次触发本 Skill 起，给每条新用户消息分配对话内单调序号，同一消息重试复用同一值。`USER_INPUT_ID` 不得包含或派生自用户输入内容、文件名、路径、截图/OCR、业务材料、stage 名或工具调用序号；运行时只保存其本地 hash，不上报。
+
+`start-run` 自动把触发当前 run 的首条用户输入计为 `before-flow`；中断/压缩后以新 `USER_INPUT_ID` 重入同一未终态 run 时，`start-run` 按当前 phase 幂等补计该消息。阻塞确认统一通过 `reply confirm --reply "$USER_REPLY" --input-id "$USER_INPUT_ID"`，该 runner 自动按当前 phase 幂等计数，禁止再为同一确认回复额外执行 `telemetry count-user-input`。其他用户输入（中途打断、补材料、只上传图片/文件、只问问题等）若不经 `reply confirm` 或 onboarding recovery，先于任何 Skill 动作或业务答复按当前 phase 执行一次 `node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" telemetry count-user-input --phase before-flow|after-flow --input-id "$USER_INPUT_ID"`；重复同一 `USER_INPUT_ID` 不加计。`*.user_confirmed` 由 flow loader 自动标记起点但不计数，after-flow 从其后的下一条用户消息开始，前置澄清和候选不计 after-flow，`full_process` 不因 Onboarding 重置。closeout 默认从本地 run state 派生计数；状态为空时用首条输入的最小合法计数，状态不可用且已核对时才显式传三项，runner 拒绝缺项、负数、`after > total`、已观测 flow start 但 `after >= total`。`terminal_reason` 为终态 runner 写入的固定低敏枚举，禁自由文本、错误详情和业务响应。不新增业务确认点或独立上报；入队后当前 `run.terminal` 文件做短超时前台 drain，失败保留 outbox 且不影响业务收口，网络类失败进入通用补传判断。脚本以当前 `run_id` 为 `PLATFORM_ID`；Agent 不手写环境前缀或改 MCP payload；维护诊断/outbox/上传/flush 见 `normal/telemetry.md`。
 
 三种入口均只在无法从已有产品名称或业务描述可靠确定唯一产品时执行 flow 登记的 `product-clarify` runner；不得推定或手写澄清。产品明确但 MCC 尚无检索输入时使用 `mcc-clarify`；已有经营描述后先按 Onboarding flow 读取一次当前 `<SKILL_DIR>/references/onboarding/modules/mcc-reference.md` 做 Agent 语义候选，再统一调用 `mcc-resolve-plan` 由 runner 复核、合并和渲染；用户直接提供当前表内完整 MCC 编码时可跳过 Agent 泛化并由 runner 精确校验。不得拆回 `mcc-search + mcc-candidates`、先旧检索失败后临时猜测，或为方案展示再拼 renderer 输入。