@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/knowledge/index.js

@@ -0,0 +1,79 @@
+import { CONCEPT_GLOSSARY, CONCEPT_GLOSSARY_VERSION, resolveTerm, lookupEntry, validateText, auditSchemaFields } from "./glossary.js";
+import { CONFIRMATION_RULES, SAFETY_RULES_VERSION } from "./safety-rules.js";
+import { TOOL_CONSTRAINTS, TOOL_CONSTRAINTS_VERSION, validateOperation, hasBlockingViolations, getWarningViolations, } from "./tool-constraints.js";
+import { PERMISSION_TYPES, GAME_ELEMENTS, getPermissionType, getGameElement, getGameElementsByType, PROCESS_MODEL_VERSION, } from "./process-model.js";
+import { computeTrustScore, quickRiskAssessment, ARBITRATION_TRUST_VERSION, } from "./arbitration-trust.js";
+import { REWARD_TEMPLATES, REWARD_TEMPLATES_VERSION, getRewardTemplate, listRewardTemplates, suggestRewardTemplate, } from "./reward-templates.js";
+import { AUDIT_RULES, AUDIT_RULES_VERSION, auditService, hasBlockingErrors, getErrors, getWarnings, summarizeFindings, } from "./audit-rules.js";
+import { matchDemand, extractDemandInfo, DEMAND_MATCHING_VERSION, } from "./demand-matching.js";
+import { suggestPricing, getMutableFields, getMutableField, MUTABLE_FIELDS, DYNAMIC_PRICING_VERSION, } from "./dynamic-pricing.js";
+import { computeServiceTrustScore, quickTrustCheck, TRUST_METRICS_VERSION, } from "./trust-metrics.js";
+import { buildReviewRepositorySetup, computeReviewStats, isVerifiedReview, filterVerifiedReviews, detectReviewManipulation, REPUTATION_RULES_VERSION, } from "./reputation-rules.js";
+import { INDUSTRY_FLYWHEELS, getFlywheelForIndustry, listIndustries, suggestAcquisitionActions, generateTrustDescription, buildAcquisitionDashboard, ACQUISITION_FLYWHEEL_VERSION, } from "./acquisition-flywheel.js";
+import { INDUSTRY_REGISTRY_VERSION, getIndustryProfile, registerIndustry, getIndustryTraits, resolveIndustryName, getRegistrySize, listBuiltinIndustryNames, } from "./industry-registry.js";
+import { DEFAULT_TRAITS, inferTraitsFromDescription, synthesizeProfile, findSimilarIndustries, composeIndustries, } from "./industry-generalizer.js";
+import { INDUSTRY_EVOLUTION_THRESHOLDS, aggregateIndustryMetrics, evaluateIndustryHealth, suggestIndustryUpdate, applyIndustryUpdate, runIndustryHealthPipeline, } from "./industry-evolution.js";
+import { FLYWHEEL_LOOP_VERSION, FLYWHEEL_LOOP_MIN_SIGNALS, EVOLUTION_STATE_VERSION, recordIndustrySignal, updateIndustryCognition, injectEvolutionContext, getIndustryEvolutionStatus, getIndustrySignalCount, getIndustrySignals, listIndustriesWithSignals, getPendingSuggestions, recordDecisionContext, queryDecisionsByIndustry, queryDecisionsByNode, backfillDecisionOutcome, setEvolutionSchedule, getEvolutionSchedule, setIndustryIntent, getIndustryIntent, saveEvolutionState, loadEvolutionState, hasPersistedEvolutionState, } from "./flywheel-loop.js";
+import { BUILTIN_INTENT_SPECS, registerIntentProfile, getIntentProfile, listIntents, evaluateIndustryHealthByIntent, suggestIndustryUpdateByIntent, evaluateIndustryHealthMultiIntent, getRoleAdvice, filterSuggestionsByRole, } from "./intent-metrics.js";
+import { GUARD_SCENES, findScene, inferSceneFromAction, getImmutableScenes, getNumericIdentifierScenes, } from "./guard-ledger.js";
+import { SEMANTIC_TO_SCHEMA_RULES, SCHEMA_TO_SEMANTIC_RULES, GUARD_CONSTRAINT_RULES, matchSemanticPattern, explainNode, explainWitness, getConstraintsByCategory, } from "./guard-translation.js";
+import { checkPuzzleCompleteness, generateConfirmationText, initPuzzleFromIntent, inferBindingFromAction, } from "./guard-puzzle.js";
+import { assessGuardRisks, assessGuardRisksForOperation, getRiskSummary, } from "./guard-risk.js";
+export { CONCEPT_GLOSSARY, CONCEPT_GLOSSARY_VERSION, resolveTerm, lookupEntry, validateText, auditSchemaFields, };
+export { CONFIRMATION_RULES, SAFETY_RULES_VERSION, };
+export { TOOL_CONSTRAINTS, TOOL_CONSTRAINTS_VERSION, validateOperation, hasBlockingViolations, getWarningViolations, };
+export { PERMISSION_TYPES, GAME_ELEMENTS, getPermissionType, getGameElement, getGameElementsByType, PROCESS_MODEL_VERSION, };
+export { computeTrustScore, quickRiskAssessment, ARBITRATION_TRUST_VERSION, };
+export { REWARD_TEMPLATES, REWARD_TEMPLATES_VERSION, getRewardTemplate, listRewardTemplates, suggestRewardTemplate, };
+export { AUDIT_RULES, AUDIT_RULES_VERSION, auditService, hasBlockingErrors, getErrors, getWarnings, summarizeFindings, };
+export { matchDemand, extractDemandInfo, DEMAND_MATCHING_VERSION, };
+export { suggestPricing, getMutableFields, getMutableField, MUTABLE_FIELDS, DYNAMIC_PRICING_VERSION, };
+export { computeServiceTrustScore, quickTrustCheck, TRUST_METRICS_VERSION, };
+export { buildReviewRepositorySetup, computeReviewStats, isVerifiedReview, filterVerifiedReviews, detectReviewManipulation, REPUTATION_RULES_VERSION, };
+export { INDUSTRY_FLYWHEELS, getFlywheelForIndustry, listIndustries, suggestAcquisitionActions, generateTrustDescription, buildAcquisitionDashboard, ACQUISITION_FLYWHEEL_VERSION, };
+export { INDUSTRY_REGISTRY_VERSION, getIndustryProfile, listIndustries as listRegistryIndustries, registerIndustry, getIndustryTraits, resolveIndustryName, getRegistrySize, listBuiltinIndustryNames, };
+export { DEFAULT_TRAITS, inferTraitsFromDescription, synthesizeProfile, findSimilarIndustries, composeIndustries, };
+export { INDUSTRY_EVOLUTION_THRESHOLDS, aggregateIndustryMetrics, evaluateIndustryHealth, suggestIndustryUpdate, applyIndustryUpdate, runIndustryHealthPipeline, };
+export { FLYWHEEL_LOOP_VERSION, FLYWHEEL_LOOP_MIN_SIGNALS, EVOLUTION_STATE_VERSION, recordIndustrySignal, updateIndustryCognition, injectEvolutionContext, getIndustryEvolutionStatus, getIndustrySignalCount, getIndustrySignals, listIndustriesWithSignals, getPendingSuggestions, recordDecisionContext, queryDecisionsByIndustry, queryDecisionsByNode, backfillDecisionOutcome, setEvolutionSchedule, getEvolutionSchedule, setIndustryIntent, getIndustryIntent, saveEvolutionState, loadEvolutionState, hasPersistedEvolutionState, };
+export { BUILTIN_INTENT_SPECS, registerIntentProfile, getIntentProfile, listIntents, evaluateIndustryHealthByIntent, suggestIndustryUpdateByIntent, evaluateIndustryHealthMultiIntent, getRoleAdvice, filterSuggestionsByRole, };
+export { GUARD_SCENES, findScene, inferSceneFromAction, getImmutableScenes, getNumericIdentifierScenes, };
+export { SEMANTIC_TO_SCHEMA_RULES, SCHEMA_TO_SEMANTIC_RULES, GUARD_CONSTRAINT_RULES, matchSemanticPattern, explainNode, explainWitness, getConstraintsByCategory, };
+export { checkPuzzleCompleteness, generateConfirmationText, initPuzzleFromIntent, inferBindingFromAction, };
+export { assessGuardRisks, assessGuardRisksForOperation, getRiskSummary, };
+export function getKnowledgeBase() {
+    return {
+        version: {
+            glossary: CONCEPT_GLOSSARY_VERSION,
+            safety: SAFETY_RULES_VERSION,
+            tool_constraints: TOOL_CONSTRAINTS_VERSION,
+            process_model: PROCESS_MODEL_VERSION,
+            arbitration_trust: ARBITRATION_TRUST_VERSION,
+            reward_templates: REWARD_TEMPLATES_VERSION,
+            audit_rules: AUDIT_RULES_VERSION,
+            demand_matching: DEMAND_MATCHING_VERSION,
+            dynamic_pricing: DYNAMIC_PRICING_VERSION,
+            trust_metrics: TRUST_METRICS_VERSION,
+            reputation_rules: REPUTATION_RULES_VERSION,
+            acquisition_flywheel: ACQUISITION_FLYWHEEL_VERSION,
+            industry_registry: INDUSTRY_REGISTRY_VERSION,
+            flywheel_loop: FLYWHEEL_LOOP_VERSION,
+        },
+        glossary_entries: CONCEPT_GLOSSARY.length,
+        confirmation_rules: CONFIRMATION_RULES.length,
+        confirmation_rule_ids: CONFIRMATION_RULES.map((r) => r.id),
+        tool_constraints_count: TOOL_CONSTRAINTS.length,
+        permission_types_count: PERMISSION_TYPES.length,
+        game_elements_count: GAME_ELEMENTS.length,
+        reward_templates_count: REWARD_TEMPLATES.length,
+        audit_rules_count: AUDIT_RULES.length,
+        mutable_fields_count: MUTABLE_FIELDS.length,
+        industry_flywheels_count: INDUSTRY_FLYWHEELS.length,
+        industry_registry_count: getRegistrySize(),
+        intent_count: listIntents().length,
+        guard_scenes_count: GUARD_SCENES.length,
+        guard_semantic_rules_count: SEMANTIC_TO_SCHEMA_RULES.length,
+        guard_schema_rules_count: SCHEMA_TO_SEMANTIC_RULES.length,
+        guard_constraint_rules_count: GUARD_CONSTRAINT_RULES.length,
+        guard_risk_rules_count: 14,
+    };
+}

package/dist/knowledge/industry-evolution.d.ts

@@ -0,0 +1,82 @@
+import type { IndustryTraits } from "./industry-registry.js";
+export interface IndustryMetrics {
+    industry: string;
+    sample_size: number;
+    time_window_days: number;
+    total_orders: number;
+    completed_rate: number;
+    dispute_rate: number;
+    refund_rate: number;
+    repeat_buyer_rate: number;
+    avg_cycle_hours: number;
+    avg_ticket_size: bigint;
+    trait_signals: Partial<Record<keyof IndustryTraits, unknown>>;
+    emerging_patterns: string[];
+    anomalies: string[];
+    collected_at: number;
+}
+export interface OrderRawDataPoint {
+    industry: string;
+    completed: boolean;
+    has_dispute: boolean;
+    has_refund: boolean;
+    cycle_hours?: number;
+    ticket_size: bigint;
+    buyer_id?: string;
+    has_milestone?: boolean;
+    has_logistics_signal?: boolean;
+    has_deposit_signal?: boolean;
+    timestamp: number;
+}
+declare const THRESHOLDS: {
+    readonly min_sample_size: 10;
+    readonly thriving_completed_rate: 0.9;
+    readonly healthy_completed_rate: 0.75;
+    readonly stressed_completed_rate: 0.6;
+    readonly thriving_dispute_rate: 0.05;
+    readonly healthy_dispute_rate: 0.1;
+    readonly stressed_dispute_rate: 0.2;
+    readonly thriving_repeat_rate: 0.3;
+    readonly healthy_repeat_rate: 0.15;
+};
+export declare function aggregateIndustryMetrics(industry: string, rawData: OrderRawDataPoint[], timeWindowDays?: number): IndustryMetrics;
+export interface TraitDrift {
+    trait: keyof IndustryTraits;
+    template_value: unknown;
+    observed_value: unknown;
+    drift_severity: "low" | "medium" | "high";
+}
+export interface IndustryHealthReport {
+    industry: string;
+    health_score: number;
+    level: "thriving" | "healthy" | "stressed" | "declining";
+    strengths: string[];
+    weaknesses: string[];
+    recommendations: string[];
+    trait_drift?: TraitDrift[];
+}
+export declare function evaluateIndustryHealth(industry: string, metrics: IndustryMetrics): IndustryHealthReport;
+export interface IndustryUpdateSuggestion {
+    industry: string;
+    suggestion_type: "add_risk_check" | "adjust_preference" | "update_flywheel" | "trait_correction";
+    field: string;
+    current_value: unknown;
+    suggested_value: unknown;
+    evidence: string;
+    confidence: number;
+    priority: "low" | "medium" | "high";
+}
+export declare function suggestIndustryUpdate(industry: string, metrics: IndustryMetrics): IndustryUpdateSuggestion[];
+export declare function applyIndustryUpdate(industry: string, suggestion: IndustryUpdateSuggestion, opts?: {
+    force?: boolean;
+}): boolean;
+export declare function runIndustryHealthPipeline(industry: string, rawData: OrderRawDataPoint[], opts?: {
+    applySuggestions?: boolean;
+    timeWindowDays?: number;
+}): {
+    metrics: IndustryMetrics;
+    health: IndustryHealthReport;
+    suggestions: IndustryUpdateSuggestion[];
+    applied: number;
+};
+export { THRESHOLDS as INDUSTRY_EVOLUTION_THRESHOLDS };

package/dist/knowledge/industry-evolution.js

@@ -0,0 +1,323 @@
+import { getIndustryProfile, getIndustryTraits, registerIndustry } from "./industry-registry.js";
+const THRESHOLDS = {
+    min_sample_size: 10,
+    thriving_completed_rate: 0.9,
+    healthy_completed_rate: 0.75,
+    stressed_completed_rate: 0.6,
+    thriving_dispute_rate: 0.05,
+    healthy_dispute_rate: 0.1,
+    stressed_dispute_rate: 0.2,
+    thriving_repeat_rate: 0.3,
+    healthy_repeat_rate: 0.15,
+};
+export function aggregateIndustryMetrics(industry, rawData, timeWindowDays = 30) {
+    const filtered = rawData.filter((d) => d.industry === industry);
+    const sample_size = filtered.length;
+    const now = Date.now();
+    if (sample_size === 0) {
+        return {
+            industry,
+            sample_size: 0,
+            time_window_days: timeWindowDays,
+            total_orders: 0,
+            completed_rate: 0,
+            dispute_rate: 0,
+            refund_rate: 0,
+            repeat_buyer_rate: 0,
+            avg_cycle_hours: 0,
+            avg_ticket_size: 0n,
+            trait_signals: {},
+            emerging_patterns: [],
+            anomalies: [],
+            collected_at: now,
+        };
+    }
+    const completedCount = filtered.filter((d) => d.completed).length;
+    const disputeCount = filtered.filter((d) => d.has_dispute).length;
+    const refundCount = filtered.filter((d) => d.has_refund).length;
+    const buyerCounts = new Map();
+    for (const d of filtered) {
+        if (d.buyer_id) {
+            buyerCounts.set(d.buyer_id, (buyerCounts.get(d.buyer_id) ?? 0) + 1);
+        }
+    }
+    const uniqueBuyers = buyerCounts.size;
+    const repeatBuyers = Array.from(buyerCounts.values()).filter((c) => c >= 2).length;
+    const repeatBuyerRate = uniqueBuyers > 0 ? repeatBuyers / uniqueBuyers : 0;
+    const cycleSamples = filtered.filter((d) => d.completed && typeof d.cycle_hours === "number");
+    const avgCycleHours = cycleSamples.length > 0
+        ? cycleSamples.reduce((s, d) => s + (d.cycle_hours ?? 0), 0) / cycleSamples.length
+        : 0;
+    const totalTicket = filtered.reduce((s, d) => s + d.ticket_size, 0n);
+    const avgTicketSize = totalTicket / BigInt(sample_size);
+    const traitSignals = {};
+    if (sample_size >= 5) {
+        const logisticsHit = filtered.filter((d) => d.has_logistics_signal).length / sample_size;
+        if (logisticsHit > 0.5)
+            traitSignals.has_logistics = true;
+        else if (logisticsHit < 0.2)
+            traitSignals.has_logistics = false;
+        const depositHit = filtered.filter((d) => d.has_deposit_signal).length / sample_size;
+        if (depositHit > 0.5)
+            traitSignals.deposit_required = true;
+        else if (depositHit < 0.2)
+            traitSignals.deposit_required = false;
+        const milestoneHit = filtered.filter((d) => d.has_milestone).length / sample_size;
+        if (milestoneHit > 0.5)
+            traitSignals.long_cycle = true;
+    }
+    const emerging_patterns = [];
+    const anomalies = [];
+    const disputeRate = disputeCount / sample_size;
+    const refundRate = refundCount / sample_size;
+    if (sample_size >= 20) {
+        if (milestoneRate(filtered) > 0.4) {
+            emerging_patterns.push("分阶段交付占比上升（≥40% 订单采用里程碑节点）");
+        }
+        if (repeatBuyerRate > 0.25) {
+            emerging_patterns.push(`复购率上升至 ${Math.round(repeatBuyerRate * 100)}%`);
+        }
+        if (disputeRate > THRESHOLDS.stressed_dispute_rate) {
+            anomalies.push(`争议率突增至 ${Math.round(disputeRate * 100)}%（阈值 ${THRESHOLDS.stressed_dispute_rate * 100}%）`);
+        }
+        if (refundRate > 0.2) {
+            anomalies.push(`退款率突增至 ${Math.round(refundRate * 100)}%`);
+        }
+        if (avgCycleHours > 24 * 30) {
+            anomalies.push(`平均完成周期过长（${Math.round(avgCycleHours / 24)} 天）`);
+        }
+    }
+    return {
+        industry,
+        sample_size,
+        time_window_days: timeWindowDays,
+        total_orders: sample_size,
+        completed_rate: completedCount / sample_size,
+        dispute_rate: disputeRate,
+        refund_rate: refundRate,
+        repeat_buyer_rate: repeatBuyerRate,
+        avg_cycle_hours: avgCycleHours,
+        avg_ticket_size: avgTicketSize,
+        trait_signals: traitSignals,
+        emerging_patterns,
+        anomalies,
+        collected_at: now,
+    };
+}
+function milestoneRate(data) {
+    if (data.length === 0)
+        return 0;
+    return data.filter((d) => d.has_milestone).length / data.length;
+}
+export function evaluateIndustryHealth(industry, metrics) {
+    const strengths = [];
+    const weaknesses = [];
+    const recommendations = [];
+    if (metrics.sample_size < THRESHOLDS.min_sample_size) {
+        weaknesses.push(`样本量不足（${metrics.sample_size} < ${THRESHOLDS.min_sample_size}），评估置信度低`);
+        recommendations.push("继续累积订单数据以提升评估精度");
+    }
+    const completedScore = metrics.completed_rate * 35;
+    if (metrics.completed_rate >= THRESHOLDS.thriving_completed_rate) {
+        strengths.push(`完成率高（${Math.round(metrics.completed_rate * 100)}%）`);
+    }
+    else if (metrics.completed_rate < THRESHOLDS.healthy_completed_rate) {
+        weaknesses.push(`完成率偏低（${Math.round(metrics.completed_rate * 100)}%）`);
+        recommendations.push("排查未完成订单根因，建议加强 Messenger 沟通与里程碑验收");
+    }
+    const disputeScore = (1 - Math.min(1, metrics.dispute_rate)) * 25;
+    if (metrics.dispute_rate <= THRESHOLDS.thriving_dispute_rate) {
+        strengths.push(`争议率低（${Math.round(metrics.dispute_rate * 100)}%）`);
+    }
+    else if (metrics.dispute_rate > THRESHOLDS.stressed_dispute_rate) {
+        weaknesses.push(`争议率高（${Math.round(metrics.dispute_rate * 100)}%）`);
+        recommendations.push("争议率超阈值，建议强制配置仲裁 + 赔偿金 + 交付 Guard");
+    }
+    const refundScore = (1 - Math.min(1, metrics.refund_rate)) * 15;
+    if (metrics.refund_rate > 0.2) {
+        weaknesses.push(`退款率高（${Math.round(metrics.refund_rate * 100)}%）`);
+        recommendations.push("退款率异常，建议检查交付质量或商品描述一致性");
+    }
+    const repeatScore = Math.min(1, metrics.repeat_buyer_rate) * 15;
+    if (metrics.repeat_buyer_rate >= THRESHOLDS.thriving_repeat_rate) {
+        strengths.push(`复购率高（${Math.round(metrics.repeat_buyer_rate * 100)}%）`);
+    }
+    else if (metrics.repeat_buyer_rate < THRESHOLDS.healthy_repeat_rate && metrics.sample_size >= 20) {
+        weaknesses.push(`复购率低（${Math.round(metrics.repeat_buyer_rate * 100)}%）`);
+        recommendations.push("复购率低，建议设置忠诚度 Reward + 推荐返现裂变");
+    }
+    const cycleScore = metrics.avg_cycle_hours > 0
+        ? Math.max(0, Math.min(10, 10 * (1 - (metrics.avg_cycle_hours / 24 - 7) / 23)))
+        : 0;
+    if (metrics.avg_cycle_hours > 0 && metrics.avg_cycle_hours <= 24 * 7) {
+        strengths.push(`交付周期短（${Math.round(metrics.avg_cycle_hours)} 小时）`);
+    }
+    else if (metrics.avg_cycle_hours > 24 * 30) {
+        weaknesses.push(`交付周期过长（${Math.round(metrics.avg_cycle_hours / 24)} 天）`);
+        recommendations.push("交付周期过长，建议优化 Machine 节点拆分");
+    }
+    const healthScore = Math.round(completedScore + disputeScore + refundScore + repeatScore + cycleScore);
+    let level;
+    if (healthScore >= 85)
+        level = "thriving";
+    else if (healthScore >= 65)
+        level = "healthy";
+    else if (healthScore >= 45)
+        level = "stressed";
+    else
+        level = "declining";
+    const traitDrift = detectTraitDrift(industry, metrics);
+    return {
+        industry,
+        health_score: healthScore,
+        level,
+        strengths,
+        weaknesses,
+        recommendations,
+        trait_drift: traitDrift.length > 0 ? traitDrift : undefined,
+    };
+}
+function detectTraitDrift(industry, metrics) {
+    const templateTraits = getIndustryTraits(industry);
+    if (!templateTraits)
+        return [];
+    const drifts = [];
+    const signals = metrics.trait_signals;
+    for (const [k, observed] of Object.entries(signals)) {
+        const templateValue = templateTraits[k];
+        if (templateValue !== observed) {
+            const isBoolean = typeof templateValue === "boolean";
+            const severity = isBoolean ? "medium" : "high";
+            drifts.push({
+                trait: k,
+                template_value: templateValue,
+                observed_value: observed,
+                drift_severity: severity,
+            });
+        }
+    }
+    return drifts;
+}
+export function suggestIndustryUpdate(industry, metrics) {
+    if (metrics.sample_size < THRESHOLDS.min_sample_size) {
+        return [];
+    }
+    const suggestions = [];
+    if (metrics.dispute_rate > THRESHOLDS.healthy_dispute_rate) {
+        suggestions.push({
+            industry,
+            suggestion_type: "add_risk_check",
+            field: "risk_checks",
+            current_value: "（无对应高争议行业的额外检查）",
+            suggested_value: {
+                id: `auto_dispute_check_${industry}`,
+                description: "争议率高发行业：强制配置仲裁 + 赔偿金",
+                weight: 30,
+            },
+            evidence: `dispute_rate=${(metrics.dispute_rate * 100).toFixed(1)}% 超过阈值 ${THRESHOLDS.healthy_dispute_rate * 100}%`,
+            confidence: Math.min(0.95, 0.5 + metrics.dispute_rate),
+            priority: metrics.dispute_rate > THRESHOLDS.stressed_dispute_rate ? "high" : "medium",
+        });
+    }
+    if (metrics.completed_rate < THRESHOLDS.healthy_completed_rate && metrics.avg_cycle_hours > 0) {
+        const currentCycleDays = Math.ceil(metrics.avg_cycle_hours / 24);
+        suggestions.push({
+            industry,
+            suggestion_type: "adjust_preference",
+            field: "preference_template.max_acceptable_cycle",
+            current_value: currentCycleDays,
+            suggested_value: Math.max(7, Math.floor(currentCycleDays * 0.8)),
+            evidence: `completed_rate=${(metrics.completed_rate * 100).toFixed(1)}% < ${THRESHOLDS.healthy_completed_rate * 100}%；avg_cycle=${currentCycleDays}天`,
+            confidence: 0.7,
+            priority: "medium",
+        });
+    }
+    if (metrics.repeat_buyer_rate >= THRESHOLDS.thriving_repeat_rate) {
+        suggestions.push({
+            industry,
+            suggestion_type: "update_flywheel",
+            field: "flywheel.rewardStrategy",
+            current_value: "（当前 Reward 策略）",
+            suggested_value: "强化忠诚度 Reward + 阶梯复购奖励",
+            evidence: `repeat_buyer_rate=${(metrics.repeat_buyer_rate * 100).toFixed(1)}% ≥ ${THRESHOLDS.thriving_repeat_rate * 100}%`,
+            confidence: 0.75,
+            priority: "low",
+        });
+    }
+    const drifts = detectTraitDrift(industry, metrics);
+    for (const d of drifts) {
+        suggestions.push({
+            industry,
+            suggestion_type: "trait_correction",
+            field: `traits.${d.trait}`,
+            current_value: d.template_value,
+            suggested_value: d.observed_value,
+            evidence: `模板假设 ${d.trait}=${d.template_value}，但实际数据观察为 ${d.observed_value}（drift_severity=${d.drift_severity}）`,
+            confidence: d.drift_severity === "high" ? 0.8 : 0.65,
+            priority: d.drift_severity === "high" ? "high" : "medium",
+        });
+    }
+    return suggestions;
+}
+export function applyIndustryUpdate(industry, suggestion, opts) {
+    if (!opts?.force) {
+        if (suggestion.confidence < 0.7)
+            return false;
+        if (suggestion.priority === "low")
+            return false;
+    }
+    const profile = getIndustryProfile(industry);
+    if (!profile)
+        return false;
+    const updated = JSON.parse(JSON.stringify(profile));
+    switch (suggestion.suggestion_type) {
+        case "trait_correction": {
+            const traitKey = suggestion.field.replace("traits.", "");
+            updated.traits[traitKey] = suggestion.suggested_value;
+            break;
+        }
+        case "adjust_preference": {
+            if (suggestion.field === "preference_template.max_acceptable_cycle") {
+                updated.preference_template.max_acceptable_cycle = suggestion.suggested_value;
+            }
+            break;
+        }
+        case "add_risk_check": {
+            const newCheck = suggestion.suggested_value;
+            if (!updated.risk_checks.find((c) => c.id === newCheck.id)) {
+                updated.risk_checks.push(newCheck);
+            }
+            break;
+        }
+        case "update_flywheel": {
+            if (suggestion.field === "flywheel.rewardStrategy") {
+                updated.flywheel.rewardStrategy = suggestion.suggested_value;
+            }
+            break;
+        }
+    }
+    const currentVersion = parseInt(updated.version.replace(/^v/, ""), 10) || 1;
+    updated.version = `v${currentVersion + 1}`;
+    updated.evolution = {
+        version: updated.evolution ? updated.evolution.version + 1 : 1,
+        last_updated: Date.now(),
+        signal_count: updated.evolution?.signal_count ?? 0,
+        pending_suggestions: Math.max(0, (updated.evolution?.pending_suggestions ?? 0) - 1),
+        last_health_score: updated.evolution?.last_health_score,
+    };
+    return registerIndustry(updated);
+}
+export function runIndustryHealthPipeline(industry, rawData, opts) {
+    const metrics = aggregateIndustryMetrics(industry, rawData, opts?.timeWindowDays ?? 30);
+    const health = evaluateIndustryHealth(industry, metrics);
+    const suggestions = suggestIndustryUpdate(industry, metrics);
+    let applied = 0;
+    if (opts?.applySuggestions) {
+        for (const s of suggestions) {
+            if (applyIndustryUpdate(industry, s))
+                applied++;
+        }
+    }
+    return { metrics, health, suggestions, applied };
+}
+export { THRESHOLDS as INDUSTRY_EVOLUTION_THRESHOLDS };

package/dist/knowledge/industry-generalizer.d.ts

@@ -0,0 +1,17 @@
+import { type IndustryTraits, type IndustryProfile } from "./industry-registry.js";
+export declare const DEFAULT_TRAITS: IndustryTraits;
+export interface TraitInferenceResult {
+    traits: IndustryTraits;
+    confidence: number;
+    matched_keywords: string[];
+    trait_confidence: Partial<Record<keyof IndustryTraits, number>>;
+}
+export declare function inferTraitsFromDescription(description: string): TraitInferenceResult;
+export interface SimilarIndustryMatch {
+    industry: string;
+    similarity: number;
+    matched_traits: string[];
+}
+export declare function findSimilarIndustries(traits: IndustryTraits, limit?: number): SimilarIndustryMatch[];
+export declare function synthesizeProfile(traits: IndustryTraits, name?: string): IndustryProfile;
+export declare function composeIndustries(names: string[], newName?: string): IndustryProfile | undefined;