@alipay/alipay-aipay 1.6.7-beta2 → 1.6.7

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

@@ -4,12 +4,12 @@ import https from 'node:https';
 import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
-import { execFileSync, spawn } from 'node:child_process';
+import { execFileSync, spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 const internalPrefix = 'ALIPAY_AIPAY_INTERNAL:';
 const disableValues = new Set(['0', 'false', 'off', 'no']);
-const canonicalProductTypes = new Set(['AIPAY', 'WEBPAY', 'APPPAY', 'UNKNOWN']);
+const canonicalProductTypes = new Set(['AIPAY', 'WEBPAY', 'APPPAY']);
 const allowedRootIntents = new Set(['integration_only', 'onboarding_only', 'full_process']);
 const syncLogBizType = 'yuyanmonitorl';
 const syncLogServerURL = 'https://collect.alipay.com/yuyan/';
@@ -17,7 +17,7 @@ const syncLogMonitorVersion = 'alipay-aipay-skill:sync-log';
 const syncLogCode = '1005';
 const syncLogMsg = 'alipay_aipay_skill_event';
 const syncLogYuyanID = '180020010001290755';
-const uploadTimeoutMs = 2500;
+const uploadTimeoutMs = 3000;
 const permissionedForegroundFlushLimit = 5;
 const localWriteMaxAttempts = 2;
 const runStateLockWaitMs = 5000;
@@ -51,24 +51,13 @@ const permissionedFlushNetworkErrors = new Set([
   'ENETUNREACH',
   'NETWORK_UNREACHABLE'
 ]);
-const productByVariant = { AIPAY: 'AIPAY', WEBPAY: 'WEBPAY', APPPAY: 'APPPAY' };
-const productByName = {
-  'AI 按量付费': 'AIPAY',
-  'AI 网页应用收款': 'WEBPAY',
-  'AI 移动应用收款': 'APPPAY',
-  按量付费: 'AIPAY',
-  网站支付: 'WEBPAY',
-  'APP 支付': 'APPPAY'
-};
 const productAliases = {
   aipay: 'AIPAY',
   webpay: 'WEBPAY',
   apppay: 'APPPAY',
-  unknown: 'UNKNOWN',
   AIPAY: 'AIPAY',
   WEBPAY: 'WEBPAY',
-  APPPAY: 'APPPAY',
-  UNKNOWN: 'UNKNOWN'
+  APPPAY: 'APPPAY'
 };
 
 export const approvedStages = Object.freeze([
@@ -142,17 +131,11 @@ const countedStageRoutes = Object.freeze({
 });
 
 const summaryStages = new Set(['integration_summary', 'onboarding_summary', 'all_summary']);
-const terminalMessageIds = new Set([
-  'product.unsupported',
-  'onboarding.windows.redirect',
-  'onboarding.enterprise.unsupported'
-]);
-
 function flowForStage(stage) {
   if (stage.startsWith('integration.')) return 'integration';
   if (stage.startsWith('onboarding.')) return 'onboarding';
   if (summaryStages.has(stage)) return 'common';
-  return '';
+  return 'common';
 }
 
 const stageRules = new Map(approvedStages.map((stage) => [stage, {
@@ -166,10 +149,9 @@ function routeStages(rootIntent, productType) {
 }
 
 function completedStageList(state) {
-  const progress = state?.stage_progress;
-  if (!progress || typeof progress !== 'object' || Array.isArray(progress)) return [];
-  const stages = Array.isArray(progress.completed_stages) ? progress.completed_stages : [];
-  return stages.filter((stage) => approvedStages.includes(stage));
+  const events = state?.stage_events;
+  if (!events || typeof events !== 'object' || Array.isArray(events)) return [];
+  return Object.keys(events).filter((stage) => approvedStages.includes(stage));
 }
 
 function stageAlreadyRecorded(state, stage) {
@@ -201,7 +183,9 @@ function messageStageFor(messageId, context = {}, env = process.env) {
     case 'integration.checklist.result':
       return 'integration_summary';
     case 'process.partial_result':
-      return context.rootIntent === 'full_process' || context.root_intent === 'full_process'
+      return context.rootIntent === 'full_process'
+        || context.root_intent === 'full_process'
+        || currentRunContext(env)?.root_intent === 'full_process'
         ? 'all_summary'
         : 'onboarding_summary';
     default:
@@ -218,60 +202,6 @@ function shouldCloseRunAfterStage(event, state = {}) {
   return false;
 }
 
-function closeRunLifecycleAfterStage(event, env = process.env) {
-  const transaction = withRunStateLock(env, () => {
-    const existing = readRunState(env);
-    if (!existing?.run_id || existing.run_id !== event.run_id) return false;
-    if (!shouldCloseRunAfterStage(event, existing)) return true;
-    const nowMs = Number.isFinite(Number(event.timestamp)) ? Number(event.timestamp) : Date.now();
-    return persistRunState({
-      ...existing,
-      terminal: true,
-      terminal_at: nowMs,
-      updated_at: nowMs
-    }, env);
-  });
-  if (!transaction.acquired) {
-    recordLocalTelemetryFailure('LOCAL_RUN_STATE_WRITE_FAILED', 'failed to lock local telemetry run state', env);
-    return false;
-  }
-  return transaction.value;
-}
-
-function updateExistingRunStateFromMessage(messageId, context = {}, env = process.env) {
-  const transaction = withRunStateLock(env, () => {
-    const existing = readRunState(env);
-    if (!existing?.run_id) return false;
-    if (!runStateCompatibleWithEventContext(existing, context)) return true;
-    const rootIntent = context.rootIntent || context.root_intent || existing.root_intent || '';
-    if (messageId === 'integration.checklist.result') {
-      if (rootIntent !== 'integration_only') return true;
-    } else if (messageId === 'process.partial_result') {
-      if (!['integration_only', 'onboarding_only', 'full_process'].includes(rootIntent)) return true;
-    } else if (!terminalMessageIds.has(messageId)) {
-      return false;
-    }
-    const nowMs = Date.now();
-    const next = {
-      ...existing,
-      schema_ver: 1,
-      run_id: existing.run_id,
-      root_intent: existing.root_intent || rootIntent,
-      product_type: existing.product_type || productTypeFrom({ context, env }),
-      created_at: existing.created_at || nowMs,
-      updated_at: nowMs,
-      terminal: true,
-      terminal_at: nowMs
-    };
-    return persistRunState(next, env);
-  });
-  if (!transaction.acquired) {
-    recordLocalTelemetryFailure('LOCAL_RUN_STATE_WRITE_FAILED', 'failed to lock local telemetry run state', env);
-    return false;
-  }
-  return transaction.value;
-}
-
 const outboxRecordFields = new Set(['schema_ver', 'created_at', 'event']);
 const metricEventFields = new Set([
   'schema_ver',
@@ -288,6 +218,7 @@ const metricEventFields = new Set([
 ]);
 const stageExtInfoFields = new Set([
   'user_input_after_clarify_intent',
+  'history_count',
   'root_intent',
   'progress_pct'
 ]);
@@ -354,7 +285,10 @@ function isMaintenanceProcess(env = process.env, argv = process.argv) {
 }
 
 function stableStateSource(env = process.env) {
-  return env.ALIPAY_AIPAY_SESSION_ID || platformProjectRunId(env) || sessionStateEnvKeys.map((key) => env[key]).find(Boolean) || '';
+  return env.ALIPAY_AIPAY_SESSION_ID
+    || sessionStateEnvKeys.map((key) => safeRunId(env[key])).find(Boolean)
+    || platformProjectId(env)
+    || '';
 }
 
 function stateKeyFromSource(source) {
@@ -468,18 +402,52 @@ function withRunStateLock(env = process.env, operation) {
   }
 }
 
+function isValidRunState(parsed) {
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
+  if (parsed.schema_ver !== 2
+    || !safeRunId(parsed.run_id)
+    || !allowedRootIntents.has(parsed.root_intent)
+    || !canonicalProductTypes.has(parsed.product_type)
+    || !['ACTIVE', 'CLOSED'].includes(parsed.lifecycle)) return false;
+  const createdAt = Number(parsed.created_at);
+  const updatedAt = Number(parsed.updated_at);
+  if (!Number.isSafeInteger(createdAt) || createdAt <= 0
+    || !Number.isSafeInteger(updatedAt) || updatedAt <= 0) return false;
+
+  // Telemetry-off runs intentionally retain only the context needed by business CLI attribution.
+  if (parsed.telemetry_disabled === true) {
+    return !Object.prototype.hasOwnProperty.call(parsed, 'counter_count')
+      && !Object.prototype.hasOwnProperty.call(parsed, 'input_hashes')
+      && !Object.prototype.hasOwnProperty.call(parsed, 'stage_events')
+      && parsed.terminal_at === null;
+  }
+
+  if (parsed.clarify_intent_recorded !== true
+    || !Number.isSafeInteger(parsed.counter_count)
+    || parsed.counter_count < 0
+    || !Array.isArray(parsed.input_hashes)
+    || new Set(parsed.input_hashes).size !== parsed.input_hashes.length
+    || parsed.input_hashes.some((hash) => typeof hash !== 'string' || !/^[a-f0-9]{32}$/u.test(hash))
+    || !parsed.stage_events || typeof parsed.stage_events !== 'object' || Array.isArray(parsed.stage_events)) return false;
+
+  const stageNames = Object.keys(parsed.stage_events);
+  if (!stageNames.includes('clarify_intent') || stageNames.some((stage) => !approvedStages.includes(stage))) return false;
+  for (const record of Object.values(parsed.stage_events)) {
+    if (!record || typeof record !== 'object' || Array.isArray(record)
+      || !safeText(record.event_id) || record.event_id.length > 128
+      || !Number.isSafeInteger(record.generated_at) || record.generated_at <= 0) return false;
+  }
+  if (parsed.lifecycle === 'ACTIVE' && parsed.terminal_at !== null) return false;
+  if (parsed.lifecycle === 'CLOSED'
+    && (!Number.isSafeInteger(parsed.terminal_at) || parsed.terminal_at <= 0)) return false;
+  return true;
+}
+
 function readRunState(env = process.env) {
   try {
     const statePath = runStatePath(env);
     const parsed = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-    if (!parsed || typeof parsed !== 'object') return null;
-    if (parsed.schema_ver !== 1) return null;
-    if (!safeRunId(parsed.run_id)) return null;
-    const createdAt = Number(parsed.created_at);
-    const updatedAt = Number(parsed.updated_at);
-    if (!Number.isFinite(createdAt) || createdAt <= 0) return null;
-    if (!Number.isFinite(updatedAt) || updatedAt <= 0) return null;
-    return parsed;
+    return isValidRunState(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -492,7 +460,7 @@ export function currentRunContext(env = process.env) {
     run_id: state.run_id,
     root_intent: state.root_intent,
     product_type: state.product_type,
-    terminal: state.terminal === true
+    terminal: state.lifecycle === 'CLOSED'
   });
 }
 
@@ -501,6 +469,7 @@ function canReadImplicitRunState(env = process.env) {
 }
 
 function recordLocalTelemetryFailure(errorCode, message, env = process.env) {
+  if (!telemetryEnabled(env)) return;
   const safeCode = safeDimension(errorCode, 'LOCAL_TELEMETRY_FAILED', 80);
   const safeMessage = safeDimension(message || safeCode, safeCode, 240);
   writeUploadStatus({
@@ -530,6 +499,7 @@ function outboxFilename(event) {
 }
 
 function writeOutboxRecord(event, env = process.env) {
+  if (!telemetryEnabled(env)) return '';
   try {
     const normalizedEvent = normalizeMetricEvent(event);
     if (!normalizedEvent) return '';
@@ -550,6 +520,7 @@ function writeOutboxRecord(event, env = process.env) {
 }
 
 export function enqueueMetricEvent(event, env = process.env) {
+  if (!telemetryEnabled(env)) return false;
   return Boolean(writeOutboxRecord(event, env));
 }
 
@@ -558,50 +529,20 @@ function safeRunId(value) {
   return /[\u0000-\u001f\u007f,^=]/u.test(value) ? '' : value;
 }
 
-function platformProjectRunId(env = process.env) {
+function platformProjectId(env = process.env) {
   for (const key of platformProjectIdEnvKeys) {
     const value = safeRunId(env[key]);
     if (value) return value;
   }
   if (env.MIAODA) {
-    return safeRunId(env.VITE_APP_ID) || safeRunId(env.PLATFORM_ID) || '';
+    return safeRunId(env.VITE_APP_ID) || '';
   }
   return '';
 }
 
-function explicitRunIdFrom(context, env) {
-  return safeRunId(context.runId || context.run_id || env.ALIPAY_AIPAY_RUN_ID || env.ALIPAY_AIPAY_FLOW_RUN_ID);
-}
-
-function runIdFrom(context, env) {
-  const state = canReadImplicitRunState(env) ? readRunState(env) : null;
-  return safeRunId(platformProjectRunId(env) || explicitRunIdFrom(context, env) || state?.run_id);
-}
-
-function rootIntentFrom(context, env) {
-  const state = canReadImplicitRunState(env) ? readRunState(env) : null;
-  const value = context.rootIntent || context.root_intent || env.ALIPAY_AIPAY_ROOT_INTENT || state?.root_intent;
-  return allowedRootIntents.has(value) ? value : '';
-}
-
 function canonicalProductType(value) {
-  return typeof value === 'string' && productAliases[value] ? productAliases[value] : '';
-}
-
-function productTypeFrom({ ruleProductType, variantName, variables = {}, context = {}, env = process.env }) {
-  const explicit = context.productType || context.product_type || ruleProductType;
-  const explicitCanonical = canonicalProductType(explicit);
-  if (explicitCanonical) return explicitCanonical;
-  const variableCanonical = canonicalProductType(variables.productType);
-  if (variableCanonical) return variableCanonical;
-  if (productByVariant[variantName]) return productByVariant[variantName];
-  if (productByName[variables.productName]) return productByName[variables.productName];
-  if (productByName[context.productName]) return productByName[context.productName];
-  const stateCanonical = canReadImplicitRunState(env) ? canonicalProductType(readRunState(env)?.product_type) : '';
-  if (stateCanonical) return stateCanonical;
-  const envCanonical = canonicalProductType(env.ALIPAY_AIPAY_PRODUCT_TYPE);
-  if (envCanonical) return envCanonical;
-  return 'UNKNOWN';
+  const canonical = typeof value === 'string' ? productAliases[value] : '';
+  return canonicalProductTypes.has(canonical) ? canonical : '';
 }
 
 function parseNonNegativeInteger(value) {
@@ -618,15 +559,6 @@ function sleepSync(ms) {
   } catch {}
 }
 
-function parseBooleanFlag(value) {
-  if (typeof value === 'boolean') return value;
-  if (typeof value !== 'string') return null;
-  const normalized = normalizeSwitch(value);
-  if (normalized === 'true' || normalized === '1') return true;
-  if (normalized === 'false' || normalized === '0') return false;
-  return null;
-}
-
 function normalizeUserInputId(value) {
   if (typeof value !== 'string') return '';
   const text = value.trim();
@@ -645,154 +577,70 @@ function normalizeUserInputHashes(value) {
   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 { user_input_after_clarify_intent: 0, input_hashes: [] };
-  }
-  const count = parseNonNegativeInteger(
-    value.user_input_after_clarify_intent ?? value.userInputAfterClarifyIntent
-  );
-  if (count === null) {
-    return { user_input_after_clarify_intent: 0, input_hashes: [] };
-  }
-  return {
-    user_input_after_clarify_intent: count,
-    input_hashes: normalizeUserInputHashes(value.input_hashes),
-    updated_at: parseNonNegativeInteger(value.updated_at) || undefined
-  };
+function parseHistoryCount(value, { strict = false } = {}) {
+  if (value === null || value === 'null' || value === undefined) return null;
+  const parsed = parseNonNegativeInteger(value);
+  if (parsed !== null) return parsed;
+  if (strict) throw new Error('--history-count 只支持非负整数或 null');
+  return undefined;
 }
 
-function validateStageCountPayload(payload = {}, env = process.env, { strict = false } = {}) {
-  const fail = (message) => {
-    if (strict) throw new Error(message);
-    return null;
-  };
+function stageExtInfoFromPayload(payload = {}) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return '';
   const userInputAfterClarifyIntent = parseNonNegativeInteger(
     payload.userInputAfterClarifyIntent ?? payload.user_input_after_clarify_intent
   );
-  const rootIntent = rootIntentFrom(payload, env);
-  if (userInputAfterClarifyIntent === null) {
-    return fail('stage 用户输入计数必须是合法非负整数');
-  }
-  if (!rootIntent) return fail('stage 用户输入计数缺少合法 root_intent');
-  return { userInputAfterClarifyIntent, rootIntent };
-}
-
-function initialUserInputCounts(nowMs = Date.now()) {
-  return {
-    user_input_after_clarify_intent: 0,
-    input_hashes: [],
-    updated_at: nowMs
-  };
-}
-
-function addUserInputCount(counts, inputId, runId, nowMs = Date.now()) {
-  const inputHash = userInputHash(inputId, runId);
-  if (!inputHash || counts.input_hashes.includes(inputHash)) return counts;
-  return {
-    ...counts,
-    user_input_after_clarify_intent: counts.user_input_after_clarify_intent + 1,
-    input_hashes: [...counts.input_hashes, inputHash],
-    updated_at: nowMs
-  };
-}
-
-function publicUserInputCountState(counts) {
-  if (!counts) return null;
-  const normalized = normalizeUserInputCounts(counts);
-  return {
-    user_input_after_clarify_intent: normalized.user_input_after_clarify_intent
-  };
-}
-
-function normalizeStageProgress(progress) {
-  if (!progress || typeof progress !== 'object' || Array.isArray(progress)) {
-    return { completed_stages: [], updated_at: 0 };
-  }
-  const completedStages = Array.isArray(progress.completed_stages)
-    ? progress.completed_stages.filter((stage) => approvedStages.includes(stage))
-    : [];
-  const seen = new Set();
-  return {
-    completed_stages: completedStages.filter((stage) => {
-      if (seen.has(stage)) return false;
-      seen.add(stage);
-      return true;
-    }),
-    updated_at: Number.isFinite(Number(progress.updated_at)) ? Number(progress.updated_at) : 0
-  };
-}
-
-function stageExtInfoFromPayload(payload = {}, env = process.env) {
-  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return '';
-  const counts = validateStageCountPayload(payload, env);
-  if (!counts) return '';
+  if (userInputAfterClarifyIntent === null) return '';
+  const historyCount = parseHistoryCount(payload.historyCount ?? payload.history_count);
+  if (historyCount === undefined) return '';
+  const rootIntent = payload.rootIntent ?? payload.root_intent;
+  if (!allowedRootIntents.has(rootIntent)) return '';
   const progressPct = Number(payload.progressPct ?? payload.progress_pct);
   if (!Number.isSafeInteger(progressPct) || progressPct < 0 || progressPct > 100) return '';
   return JSON.stringify({
-    user_input_after_clarify_intent: counts.userInputAfterClarifyIntent,
-    root_intent: counts.rootIntent,
+    user_input_after_clarify_intent: userInputAfterClarifyIntent,
+    history_count: historyCount,
+    root_intent: rootIntent,
     progress_pct: progressPct
   });
 }
 
-export function stageMetricEvent(stage, context = {}, nowMs = Date.now(), env = process.env) {
-  const rule = stageRules.get(stage);
-  if (!rule) return null;
-  const state = canReadImplicitRunState(env) ? readRunState(env) : null;
-  const explicitRunId = platformProjectRunId(env) || explicitRunIdFrom(context, env);
-  if (state && (!explicitRunId || explicitRunId === state.run_id) && !runStateCompatibleWithEventContext(state, context)) {
-    return null;
-  }
-  const runId = runIdFrom(context, env);
-  if (!runId) return null;
-  if (state && state.run_id === runId && stageAlreadyRecorded(state, rule.stage)) return null;
-  const event = {
+function legalStageForState(state, stage) {
+  if (!state || !stageRules.has(stage)) return false;
+  if (stage === 'clarify_intent') return true;
+  if (stage === 'integration_summary') return ['integration_only', 'full_process'].includes(state.root_intent);
+  if (stage === 'onboarding_summary') return state.root_intent === 'onboarding_only';
+  if (stage === 'all_summary') return state.root_intent === 'full_process';
+  return routeStages(state.root_intent, state.product_type).includes(stage);
+}
+
+function eventFromState(stage, state, historyCount, nowMs = Date.now(), eventId = crypto.randomUUID()) {
+  if (!legalStageForState(state, stage)) return null;
+  const completedStages = completedStageList(state);
+  const progressPct = stage === 'clarify_intent'
+    ? 0
+    : progressPctForStage(state.root_intent, state.product_type, stage, completedStages);
+  if (progressPct < 0) return null;
+  const extInfo = stageExtInfoFromPayload({
+    userInputAfterClarifyIntent: state.counter_count,
+    historyCount,
+    rootIntent: state.root_intent,
+    progressPct
+  });
+  if (!extInfo) return null;
+  return {
     schema_ver: 2,
-    event_id: crypto.randomUUID(),
+    event_id: eventId,
     skill: 'alipay-aipay',
     skill_version: skillVersionFromDisk(),
-    run_id: runId,
-    stage: rule.stage,
+    run_id: state.run_id,
+    stage,
     timestamp: nowMs,
-    flow: rule.flow,
-    product_type: productTypeFrom({ ruleProductType: context.productType || context.product_type, context, env })
+    flow: flowForStage(stage),
+    product_type: state.product_type,
+    root_intent: state.root_intent,
+    ext_info: extInfo
   };
-  if (!canonicalProductTypes.has(event.product_type)) event.product_type = 'UNKNOWN';
-  const rootIntent = rootIntentFrom(context, env);
-  if (rootIntent) event.root_intent = rootIntent;
-  const completedStages = completedStageList(state);
-  const progressPct = event.stage === 'clarify_intent'
-    ? 0
-    : progressPctForStage(rootIntent || state?.root_intent || '', event.product_type, event.stage, completedStages);
-  if (progressPct >= 0) {
-    const extInfo = stageExtInfoFromPayload({
-      userInputAfterClarifyIntent: state?.user_input_counts?.user_input_after_clarify_intent ?? 0,
-      rootIntent: rootIntent || state?.root_intent || '',
-      progressPct
-    }, env);
-    if (!extInfo) return null;
-    event.ext_info = extInfo;
-  } else {
-    return null;
-  }
-  return event;
-}
-
-export function messageMetricEvent(messageId, variantName, variables = {}, context = {}, nowMs = Date.now(), env = process.env) {
-  const stage = messageStageFor(messageId, context, env);
-  if (!stage) return null;
-  const stageEvent = stageMetricEvent(stage, {
-    ...context,
-    productType: productTypeFrom({ variantName, variables, context, env })
-  }, nowMs, env);
-  return stageEvent;
-}
-
-function scheduleQueuedSyncLogUpload(event, queuedFile, env = process.env) {
-  if (!queuedFile || !telemetryUploadEnabled(env)) return false;
-  spawnOutboxFlush(env);
-  return true;
 }
 
 function writeMetricEventMarker(event, stream) {
@@ -801,126 +649,36 @@ function writeMetricEventMarker(event, stream) {
   }
 }
 
-export function emitMetricEvent(event, { env = process.env, stream = process.stderr, upload = true } = {}) {
-  if (!telemetryEnabled(env)) return false;
-  const normalizedEvent = normalizeMetricEvent(event);
-  if (!normalizedEvent) return false;
-  writeMetricEventMarker(normalizedEvent, stream);
-  if (!upload) {
-    updateExistingRunStateFromStageEvent(normalizedEvent, env);
-    closeRunLifecycleAfterStage(normalizedEvent, env);
-    return true;
-  }
-  if (telemetryCaptureOnly(env)) {
-    if (writeOutboxRecord(normalizedEvent, env)) {
-      updateExistingRunStateFromStageEvent(normalizedEvent, env);
-      closeRunLifecycleAfterStage(normalizedEvent, env);
-      return true;
-    }
-    recordLocalTelemetryFailure('LOCAL_OUTBOX_WRITE_FAILED', 'outbox write failed', env);
-    return false;
-  }
-  if (!telemetryUploadEnabled(env)) {
-    updateExistingRunStateFromStageEvent(normalizedEvent, env);
-    closeRunLifecycleAfterStage(normalizedEvent, env);
-    return true;
-  }
-  const queuedFile = writeOutboxRecord(normalizedEvent, env);
-  if (!queuedFile) {
-    recordLocalTelemetryFailure('LOCAL_OUTBOX_WRITE_FAILED', 'outbox write failed', env);
-    return false;
-  }
-  updateExistingRunStateFromStageEvent(normalizedEvent, env);
-  scheduleQueuedSyncLogUpload(normalizedEvent, queuedFile, env);
-  closeRunLifecycleAfterStage(normalizedEvent, env);
-  return true;
-}
-
-export function emitStageMetricAsync(stage, context = {}, env = process.env) {
+export function emitStageMetric(stage, context = {}, env = process.env) {
   try {
     if (!telemetryEnabled(env) || !stageRules.has(stage)) return false;
-    const event = stageMetricEvent(stage, context, Date.now(), env);
-    if (!event) return false;
-    if (normalizeSwitch(env.ALIPAY_AIPAY_TEST_MODE) === '1') {
-      return emitMetricEvent(event, { env });
-    }
-    const args = [scriptPath(), 'stage', event.stage, '--timestamp-ms', String(event.timestamp)];
-    const options = [
-      ['run-id', event.run_id],
-      ['root-intent', event.root_intent],
-      ['product-type', event.product_type]
-    ];
-    for (const [name, value] of options) {
-      if (typeof value === 'string' && value) args.push(`--${name}`, value);
-    }
-    const child = spawn(process.execPath, args, {
-      detached: true,
-      stdio: 'ignore',
-      env
+    const activeRun = currentRunContext(env);
+    const runId = safeRunId(context.runId || context.run_id || env.ALIPAY_AIPAY_TELEMETRY_RUN_ID || activeRun?.run_id);
+    const historyCount = context.historyCount ?? context.history_count ?? env.ALIPAY_AIPAY_TELEMETRY_HISTORY_COUNT ?? 'null';
+    const child = spawnSync(process.execPath, [
+      scriptPath(), 'stage', stage,
+      '--run-id', runId,
+      '--history-count', String(historyCount)
+    ], {
+      stdio: normalizeSwitch(env.ALIPAY_AIPAY_TEST_MODE) === '1' ? 'inherit' : 'ignore',
+      env,
+      timeout: uploadTimeoutMs + 2000
     });
-    child.on('error', (error) => {
-      recordLocalTelemetryFailure(
-        safeDimension(error?.code || error?.name || 'TELEMETRY_STAGE_SPAWN_FAILED', 'TELEMETRY_STAGE_SPAWN_FAILED', 80),
-        safeDimension(error?.message || 'failed to start telemetry stage process', 'failed to start telemetry stage process', 240),
-        env
-      );
-    });
-    child.unref();
-    return true;
+    return !child.error && child.status === 0;
   } catch {
     return false;
   }
 }
 
-export function emitMessageMetric(messageId, variantName, variables = {}, context = {}) {
+export function emitMessageMetric(messageId, variantName, variables = {}, context = {}, env = process.env) {
   try {
-    const event = messageMetricEvent(messageId, variantName, variables, context);
-    const emitted = event ? emitMetricEvent(event, { stream: null }) : false;
-    const lifecycleUpdated = updateExistingRunStateFromMessage(messageId, context);
-    return emitted || lifecycleUpdated;
+    const stage = messageStageFor(messageId, context, env);
+    return stage ? emitStageMetric(stage, context, env) : false;
   } catch {
     return false;
   }
 }
 
-export async function startTelemetryRun(rootIntent, productType, inputId = '', {
-  runId = '',
-  env = process.env,
-  nowMs = Date.now()
-} = {}) {
-  if (typeof rootIntent !== 'string' || rootIntent.length === 0) return null;
-  if (!allowedRootIntents.has(rootIntent)) {
-    throw new Error('--root-intent 仅支持 integration_only、onboarding_only、full_process');
-  }
-  const canonicalProduct = canonicalProductType(productType);
-  if (!canonicalProduct || canonicalProduct === 'UNKNOWN') return null;
-  const transaction = withRunStateLock(env, () => {
-    const run = createOrReuseRunState({
-      'root-intent': rootIntent,
-      'product-type': canonicalProduct,
-      'run-id': runId
-    }, env, nowMs);
-    return {
-      run,
-      persisted: Boolean(run?.state && persistRunState(run.state, env))
-    };
-  });
-  if (!transaction.acquired) {
-    recordLocalTelemetryFailure('LOCAL_RUN_STATE_WRITE_FAILED', 'failed to lock local telemetry run state', env);
-    return null;
-  }
-  const { run, persisted } = transaction.value || {};
-  if (run?.state && persisted && run.reused !== true) {
-    const event = stageMetricEvent('clarify_intent', {
-      runId: run.state.run_id,
-      rootIntent: run.state.root_intent,
-      productType: run.state.product_type
-    }, nowMs, env);
-    emitMetricEvent(event, { env });
-  }
-  return run?.state || null;
-}
-
 function parseCliArgs(argv) {
   const command = argv[2];
   const args = { _: [] };
@@ -942,20 +700,11 @@ function parseCliArgs(argv) {
 function contextFromCliArgs(args) {
   const context = {
     runId: args['run-id'],
-    rootIntent: args['root-intent'],
-    productType: args['product-type'],
-    productName: args['product-name']
+    historyCount: args['history-count']
   };
   return context;
 }
 
-function timestampFromCliArgs(args) {
-  if (args['timestamp-ms'] === undefined) return Date.now();
-  const value = Number(args['timestamp-ms']);
-  if (!Number.isSafeInteger(value) || value <= 0) throw new Error('--timestamp-ms 必须是正整数毫秒时间戳');
-  return value;
-}
-
 function assertCliArgs(args, allowedOptions, positionalCount) {
   for (const name of Object.keys(args)) {
     if (name !== '_' && !allowedOptions.has(name)) throw new Error(`不支持参数 --${name}`);
@@ -968,64 +717,42 @@ function createRunState(args, env = process.env, nowMs = Date.now()) {
   if (!allowedRootIntents.has(rootIntent)) throw new Error('--root-intent 仅支持 integration_only、onboarding_only、full_process');
   const productType = canonicalProductType(args['product-type']);
   if (!productType) return null;
-  const runId = platformProjectRunId(env) || safeRunId(args['run-id']) || crypto.randomUUID();
+  const runId = crypto.randomUUID();
   return {
-    schema_ver: 1,
+    schema_ver: 2,
     run_id: runId,
     root_intent: rootIntent,
     product_type: productType,
-    user_input_counts: initialUserInputCounts(nowMs),
+    lifecycle: 'ACTIVE',
+    clarify_intent_recorded: false,
+    counter_count: 0,
+    input_hashes: [],
+    stage_events: {},
     created_at: nowMs,
-    updated_at: nowMs
+    updated_at: nowMs,
+    terminal_at: null
   };
 }
 
-function compatibleProductType(existingProductType, requestedProductType) {
-  const existing = canonicalProductType(existingProductType);
-  const requested = canonicalProductType(requestedProductType);
-  if (!existing || !requested) return false;
-  if (existing === 'UNKNOWN' || requested === 'UNKNOWN') return false;
-  return existing === requested;
-}
-
-function runStateCompatibleWithEventContext(state, context = {}) {
-  if (!state) return true;
-  const requestedRootIntent = context.rootIntent || context.root_intent;
-  if (requestedRootIntent && state.root_intent && state.root_intent !== requestedRootIntent) return false;
-  const requestedProductType = canonicalProductType(context.productType || context.product_type);
-  if (requestedProductType && !compatibleProductType(state.product_type, requestedProductType)) return false;
-  return true;
-}
-
-function mergeProductType(existingProductType, requestedProductType) {
-  const existing = canonicalProductType(existingProductType) || 'UNKNOWN';
-  const requested = canonicalProductType(requestedProductType) || 'UNKNOWN';
-  if (existing === 'UNKNOWN' && requested !== 'UNKNOWN') return requested;
-  if (requested === 'UNKNOWN' && existing !== 'UNKNOWN') return existing;
-  return requested;
-}
-
 function reusableRunState(existing, requestedRootIntent, requestedProductType) {
-  if (!existing || existing.terminal) return false;
+  if (!existing || existing.lifecycle !== 'ACTIVE') return false;
   if (existing.root_intent !== requestedRootIntent) return false;
   const existingProductType = canonicalProductType(existing.product_type);
   const nextProductType = canonicalProductType(requestedProductType);
   if (!existingProductType || !nextProductType) return false;
-  if (existingProductType === 'UNKNOWN' || nextProductType === 'UNKNOWN') return false;
   return existingProductType === nextProductType;
 }
 
 function createOrReuseRunState(args, env = process.env, nowMs = Date.now()) {
   const rootIntent = args['root-intent'];
   if (!allowedRootIntents.has(rootIntent)) throw new Error('--root-intent 仅支持 integration_only、onboarding_only、full_process');
-  const requestedProductType = canonicalProductType(args['product-type']) || 'UNKNOWN';
-  const requestedRunId = platformProjectRunId(env) || safeRunId(args['run-id']);
+  const requestedProductType = canonicalProductType(args['product-type']);
+  if (!requestedProductType) return null;
   const existing = readRunState(env);
-  if (reusableRunState(existing, rootIntent, requestedProductType) && (!requestedRunId || existing.run_id === requestedRunId)) {
+  if (reusableRunState(existing, rootIntent, requestedProductType)
+    && (telemetryEnabled(env) ? existing.clarify_intent_recorded === true : true)) {
     const state = {
       ...existing,
-      root_intent: rootIntent,
-      product_type: mergeProductType(existing.product_type, requestedProductType),
       updated_at: nowMs
     };
     return {
@@ -1037,37 +764,29 @@ function createOrReuseRunState(args, env = process.env, nowMs = Date.now()) {
   return state ? { reused: false, state } : null;
 }
 
-function withCompletedStage(state, stage, nowMs = Date.now()) {
-  const progress = normalizeStageProgress(state?.stage_progress);
-  if (progress.completed_stages.includes(stage)) return state;
-  return {
-    ...state,
-    stage_progress: {
-      completed_stages: [...progress.completed_stages, stage],
-      updated_at: nowMs
-    },
-    updated_at: nowMs
-  };
-}
-
-export function recordTelemetryUserInput(inputId, env = process.env, nowMs = Date.now()) {
+export function recordTelemetryUserInput(inputId, env = process.env, nowMs = Date.now(), runId = '') {
   if (!telemetryEnabled(env)) return null;
-  const normalizedInputId = normalizeUserInputId(inputId);
-  if (!normalizedInputId) throw new Error('用户输入计数必须提供本地幂等 --input-id，且不得包含用户输入原文或敏感信息');
   const transaction = withRunStateLock(env, () => {
     const existing = readRunState(env);
-    if (!existing?.run_id || existing.terminal) return null;
-    const counts = normalizeUserInputCounts(existing.user_input_counts);
+    const explicitRunId = safeRunId(runId);
+    if (!existing?.run_id || existing.lifecycle !== 'ACTIVE' || !explicitRunId || explicitRunId !== existing.run_id) return null;
+    const normalizedInputId = normalizeUserInputId(inputId);
+    if (!normalizedInputId) throw new Error('用户输入计数必须提供不含用户原文或敏感信息的本地幂等 --input-id');
+    const count = parseNonNegativeInteger(existing.counter_count);
+    if (count === null) return null;
+    const hashes = normalizeUserInputHashes(existing.input_hashes);
     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, normalizedInputId, existing.run_id, nowMs);
+    if (hashes.includes(inputHash)) return { user_input_after_clarify_intent: count };
     const next = {
       ...existing,
-      user_input_counts: nextCounts,
+      counter_count: count + 1,
+      input_hashes: [...hashes, inputHash],
       updated_at: nowMs
     };
-    return persistRunState(next, env) ? nextCounts : null;
+    return persistRunState(next, env)
+      ? { user_input_after_clarify_intent: next.counter_count }
+      : null;
   });
   if (!transaction.acquired) {
     recordLocalTelemetryFailure('LOCAL_RUN_STATE_WRITE_FAILED', 'failed to lock local telemetry run state', env);
@@ -1076,38 +795,116 @@ export function recordTelemetryUserInput(inputId, env = process.env, nowMs = Dat
   return transaction.value;
 }
 
-function updateExistingRunStateFromStageEvent(event, env = process.env) {
-  if (!event || !stageRules.has(event.stage)) return false;
+async function deliverPersistedStageEvent(event, env = process.env, stream = process.stderr) {
+  writeMetricEventMarker(event, stream);
+  const queuedFile = writeOutboxRecord(event, env);
+  if (!queuedFile) {
+    recordLocalTelemetryFailure('LOCAL_OUTBOX_WRITE_FAILED', 'outbox write failed', env);
+    return false;
+  }
+  writeUploadStatus({ status: 'pending', attempted: 0, sent: 0, retained: 1 }, env);
+  if (!telemetryUploadEnabled(env)) return true;
+  await flushOutbox(env, { limit: 1, targetFile: queuedFile, timeoutMs: uploadTimeoutMs });
+  if (hasPendingOutboxRecords(env)) spawnOutboxFlush(env);
+  return true;
+}
+
+export async function recordStageEvent(stage, context = {}, env = process.env, nowMs = Date.now(), stream = process.stderr) {
+  if (!telemetryEnabled(env)) return null;
+  if (!stageRules.has(stage)) throw new Error('stage 不在公开 telemetry stage 列表中');
+  const runId = safeRunId(context.runId || context.run_id);
+  const historyCount = parseHistoryCount(context.historyCount ?? context.history_count, { strict: true });
   const transaction = withRunStateLock(env, () => {
     const existing = readRunState(env);
-    if (!existing) return true;
-    if (existing.run_id !== event.run_id) return true;
-    if (!runStateCompatibleWithEventContext(existing, {
-      rootIntent: event.root_intent,
-      productType: event.product_type
-    })) return true;
-    const counts = normalizeUserInputCounts(existing.user_input_counts);
-    const route = routeStages(existing.root_intent, existing.product_type);
-    if (route.length > 0 && !route.includes(event.stage) && !summaryStages.has(event.stage)) return true;
-    const next = withCompletedStage({
+    if (!existing || existing.lifecycle !== 'ACTIVE') return { kind: 'noop' };
+    if (!runId || runId !== existing.run_id) return { kind: 'noop' };
+    if (!existing.clarify_intent_recorded || !stageAlreadyRecorded(existing, 'clarify_intent')) return { kind: 'noop' };
+    if (!legalStageForState(existing, stage) || stage === 'clarify_intent') return { kind: 'noop' };
+    if (stageAlreadyRecorded(existing, stage)) return { kind: 'duplicate' };
+    if (parseNonNegativeInteger(existing.counter_count) === null) return { kind: 'noop' };
+    const event = eventFromState(stage, existing, historyCount, nowMs);
+    if (!event) return { kind: 'noop' };
+    const closesRun = shouldCloseRunAfterStage(event, existing);
+    const next = {
       ...existing,
-      schema_ver: 1,
-      run_id: event.run_id,
-      root_intent: existing.root_intent || event.root_intent || '',
-      product_type: event.product_type && event.product_type !== 'UNKNOWN'
-        ? event.product_type
-        : existing.product_type || 'UNKNOWN',
-      created_at: existing.created_at || Date.now(),
-      updated_at: Date.now(),
-      user_input_counts: counts
-    }, event.stage, Number.isFinite(Number(event.timestamp)) ? Number(event.timestamp) : Date.now());
-    return persistRunState(next, env);
+      stage_events: {
+        ...existing.stage_events,
+        [stage]: { event_id: event.event_id, generated_at: nowMs }
+      },
+      lifecycle: closesRun ? 'CLOSED' : existing.lifecycle,
+      terminal_at: closesRun ? nowMs : existing.terminal_at,
+      updated_at: nowMs
+    };
+    return persistRunState(next, env) ? { kind: 'created', event } : { kind: 'lost' };
   });
   if (!transaction.acquired) {
     recordLocalTelemetryFailure('LOCAL_RUN_STATE_WRITE_FAILED', 'failed to lock local telemetry run state', env);
-    return false;
+    return null;
   }
-  return transaction.value;
+  const result = transaction.value;
+  if (result?.kind !== 'created') return null;
+  await deliverPersistedStageEvent(result.event, env, stream);
+  return result.event;
+}
+
+export async function startTelemetryRun(rootIntent, productType, _inputId = '', {
+  env = process.env,
+  nowMs = Date.now(),
+  stream = process.stderr
+} = {}) {
+  if (!allowedRootIntents.has(rootIntent)) {
+    if (!rootIntent) return null;
+    throw new Error('--root-intent 仅支持 integration_only、onboarding_only、full_process');
+  }
+  const canonicalProduct = canonicalProductType(productType);
+  if (!canonicalProduct) return null;
+  const enabled = telemetryEnabled(env);
+  const transaction = withRunStateLock(env, () => {
+    const run = createOrReuseRunState({
+      'root-intent': rootIntent,
+      'product-type': canonicalProduct
+    }, env, nowMs);
+    if (!run?.state) return null;
+    if (run.reused) return persistRunState(run.state, env) ? { ...run, event: null } : null;
+    let state = run.state;
+    let event = null;
+    if (enabled) {
+      event = eventFromState('clarify_intent', state, 0, nowMs);
+      if (!event) return null;
+      state = {
+        ...state,
+        clarify_intent_recorded: true,
+        stage_events: {
+          clarify_intent: { event_id: event.event_id, generated_at: nowMs }
+        }
+      };
+    } else {
+      state = {
+        schema_ver: 2,
+        run_id: state.run_id,
+        root_intent: state.root_intent,
+        product_type: state.product_type,
+        lifecycle: 'ACTIVE',
+        telemetry_disabled: true,
+        created_at: state.created_at,
+        updated_at: nowMs,
+        terminal_at: null
+      };
+    }
+    return persistRunState(state, env) ? { ...run, state, event } : null;
+  });
+  if (!transaction.acquired || !transaction.value?.state) {
+    recordLocalTelemetryFailure('LOCAL_RUN_STATE_WRITE_FAILED', 'failed to persist local telemetry run state', env);
+    return null;
+  }
+  const { state, event } = transaction.value;
+  env.ALIPAY_AIPAY_TELEMETRY_RUN_ID = state.run_id;
+  if (event) env.ALIPAY_AIPAY_TELEMETRY_HISTORY_COUNT = '0';
+  if (stream && typeof stream.write === 'function') {
+    stream.write(`${internalPrefix}RUN_ID=${state.run_id}\n`);
+  }
+  if (event) await deliverPersistedStageEvent(event, env, stream);
+  return state;
 }
 
 function normalizeOS(platform = process.platform) {
@@ -1156,7 +953,19 @@ function platformFromEnv(env = process.env) {
 }
 
 function modelFromEnv(env = process.env) {
-  return safeDimension(env.AIPAY_MODEL || 'unknown');
+  const raw = env.ALIPAY_AIPAY_MODEL || env.AIPAY_MODEL || '';
+  const normalized = String(raw).trim().toLowerCase();
+  if (!normalized) return 'unknown';
+
+  // Keep model telemetry at a coarse family level; variants and reasoning modes are not needed here.
+  if (/^(?:openai\/)?gpt[-_ ]?5(?:[.\-_ ]|$)/u.test(normalized)) return 'gpt-5';
+  if (/^(?:openai\/)?gpt[-_ ]?4(?:[.\-_ ]|$)/u.test(normalized)) return 'gpt-4';
+  if (/^claude(?:[.\-_ ]|$)/u.test(normalized)) return 'claude';
+  if (/^gemini(?:[.\-_ ]|$)/u.test(normalized)) return 'gemini';
+  if (/^qwen(?:[.\-_ ]|$)/u.test(normalized)) return 'qwen';
+  if (/^deepseek(?:[.\-_ ]|$)/u.test(normalized)) return 'deepseek';
+  if (/^llama(?:[.\-_ ]|$)/u.test(normalized)) return 'llama';
+  return 'unknown';
 }
 
 function skillVersionFromDisk() {
@@ -1458,6 +1267,7 @@ export function sendSyncLogReportDetailed(report, { timeoutMs = uploadTimeoutMs
 }
 
 function outboxFiles(env = process.env, { targetFile = '', limit = 0 } = {}) {
+  if (!telemetryEnabled(env)) return [];
   try {
     const dir = outboxDir(env);
     recoverStaleOutboxClaims(env);
@@ -1496,6 +1306,7 @@ function outboxRecordEntries(dir) {
 }
 
 function pruneOutbox(env = process.env, nowMs = Date.now()) {
+  if (!telemetryEnabled(env)) return;
   try {
     const dir = outboxDir(env);
     let entries = outboxRecordEntries(dir);
@@ -1583,6 +1394,7 @@ function readOutboxRecord(file) {
 }
 
 function hasPendingOutboxRecords(env = process.env) {
+  if (!telemetryEnabled(env)) return false;
   try {
     const dir = outboxDir(env);
     recoverStaleOutboxClaims(env);
@@ -1592,11 +1404,12 @@ function hasPendingOutboxRecords(env = process.env) {
       return name.endsWith('.json') || name.includes('.json.sending.');
     });
   } catch {
-    return true;
+    return false;
   }
 }
 
 function writeUploadStatus(status, env = process.env) {
+  if (!telemetryEnabled(env)) return false;
   return writePrivateJson(uploadStatusPath(env), { schema_ver: 1, updated_at: Date.now(), ...status });
 }
 
@@ -1624,6 +1437,9 @@ function networkUploadFailure(status) {
 }
 
 export function permissionedFlushDecision(env = process.env) {
+  if (!telemetryUploadEnabled(env)) {
+    return { needed: false, outbox_count: 0, error_code: '', status: 'disabled' };
+  }
   const outboxCount = outboxFiles(env).length;
   const status = readUploadStatus(env);
   const errorCode = networkUploadFailure(status);
@@ -1633,7 +1449,7 @@ export function permissionedFlushDecision(env = process.env) {
     error_code: errorCode || safeDimension(status?.error_code || '', '', 80),
     status: safeDimension(status?.status || 'unknown', 'unknown', 80)
   };
-  if (!telemetryUploadEnabled(env) || outboxCount <= 0 || !errorCode) {
+  if (outboxCount <= 0 || !errorCode) {
     return result;
   }
   result.needed = true;
@@ -1805,14 +1621,11 @@ 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', 'input-id']), 0);
+      assertCliArgs(args, new Set(['root-intent', 'product-type']), 0);
       if (!allowedRootIntents.has(args['root-intent'])) {
         throw new Error('--root-intent 仅支持 integration_only、onboarding_only、full_process');
       }
-      await startTelemetryRun(args['root-intent'], args['product-type'], args['input-id'], {
-        runId: args['run-id'],
-        env: process.env
-      });
+      await startTelemetryRun(args['root-intent'], args['product-type'], '', { env: process.env });
       return 0;
     }
     if (command === 'current-run-id') {
@@ -1831,10 +1644,13 @@ export async function runTelemetryCli(argv = process.argv) {
       return 0;
     }
     if (command === 'count-user-input' && args._.length === 0) {
-      assertCliArgs(args, new Set(['input-id']), 0);
-      const counts = recordTelemetryUserInput(args['input-id'], process.env, Date.now());
+      assertCliArgs(args, new Set(['run-id', 'input-id']), 0);
+      if (typeof args['input-id'] !== 'string' || !args['input-id']) {
+        throw new Error('缺少参数 --input-id');
+      }
+      const counts = recordTelemetryUserInput(args['input-id'], process.env, Date.now(), args['run-id']);
       if (counts) {
-        process.stderr.write(`${internalPrefix}USER_INPUT_COUNT_STATE=${JSON.stringify(publicUserInputCountState(counts))}\n`);
+        process.stderr.write(`${internalPrefix}USER_INPUT_COUNT_STATE=${JSON.stringify(counts)}\n`);
       } else {
         process.stderr.write(`${internalPrefix}USER_INPUT_COUNT_STATE_MISSING=true\n`);
       }
@@ -1842,12 +1658,14 @@ export async function runTelemetryCli(argv = process.argv) {
     }
     if (command === 'upload-status' && args._.length === 0) {
       assertCliArgs(args, new Set(), 0);
+      if (!telemetryEnabled(process.env)) return 0;
       const status = readUploadStatus(process.env) || { schema_ver: 1, status: 'unknown' };
       process.stderr.write(`${internalPrefix}TELEMETRY_UPLOAD_STATUS=${JSON.stringify(status)}\n`);
       return 0;
     }
     if (command === 'permissioned-flush-status' && args._.length === 0) {
       assertCliArgs(args, new Set(), 0);
+      if (!telemetryEnabled(process.env)) return 0;
       const decision = permissionedFlushDecision(process.env);
       process.stderr.write(`${internalPrefix}PERMISSIONED_FLUSH_STATUS=${JSON.stringify(decision)}\n`);
       if (decision.needed) {
@@ -1857,6 +1675,7 @@ export async function runTelemetryCli(argv = process.argv) {
     }
     if (command === 'permissioned-flush-needed' && args._.length === 0) {
       assertCliArgs(args, new Set(), 0);
+      if (!telemetryEnabled(process.env)) return 0;
       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`);
@@ -1864,13 +1683,13 @@ export async function runTelemetryCli(argv = process.argv) {
     }
     if (command === 'flush-outbox') {
       assertCliArgs(args, new Set(), 0);
-      if (!telemetryEnabled(process.env)) return 0;
+      if (!telemetryUploadEnabled(process.env)) return 0;
       await runPermissionedOutboxFlush(process.env, { spawnBackground: true });
       return 0;
     }
     if (command === 'flush-outbox-worker') {
       assertCliArgs(args, new Set(), 0);
-      if (!telemetryEnabled(process.env)) return 0;
+      if (!telemetryUploadEnabled(process.env)) return 0;
       const timeout = Number(process.env.ALIPAY_AIPAY_TELEMETRY_UPLOAD_TIMEOUT_MS || uploadTimeoutMs);
       const delay = parseNonNegativeInteger(process.env.ALIPAY_AIPAY_TELEMETRY_FLUSH_DELAY_MS);
       if (delay && delay > 0) sleepSync(Math.min(delay, 30000));
@@ -1881,29 +1700,23 @@ export async function runTelemetryCli(argv = process.argv) {
       return 0;
     }
     if (!telemetryEnabled(process.env)) return 0;
-    if (command === 'stage-async') {
-      assertCliArgs(args, new Set([
-        'run-id',
-        'root-intent',
-        'product-type',
-        'product-name'
-      ]), 1);
-      emitStageMetricAsync(args._[0], contextFromCliArgs(args), process.env);
-      return 0;
-    }
     if (command !== 'stage' || args._.length !== 1) {
       emitTelemetryError(new Error('invalid telemetry arguments'));
       return 0;
     }
     assertCliArgs(args, new Set([
       'run-id',
-      'root-intent',
-      'product-type',
-      'product-name',
-      'timestamp-ms'
+      'history-count'
     ]), 1);
-    const event = stageMetricEvent(args._[0], contextFromCliArgs(args), timestampFromCliArgs(args));
-    emitMetricEvent(event);
+    if (typeof args['run-id'] !== 'string' || !args['run-id']) throw new Error('缺少参数 --run-id');
+    if (!Object.prototype.hasOwnProperty.call(args, 'history-count')) throw new Error('缺少参数 --history-count');
+    await recordStageEvent(
+      args._[0],
+      contextFromCliArgs(args),
+      process.env,
+      Date.now(),
+      process.stderr
+    );
     return 0;
   } catch (error) {
     emitTelemetryError(error);