@wowok/agent-mcp 2.3.14 → 2.3.16

package/dist/knowledge/tool-constraints.d.ts

@@ -0,0 +1,30 @@
+export type ConstraintSeverity = "error" | "warning";
+export interface FieldConstraint {
+    field: string;
+    description: string;
+    severity: ConstraintSeverity;
+    check: (data: any) => boolean;
+    message: (data: any) => string;
+}
+export interface OperationConstraint {
+    operation_type: string;
+    constraints: FieldConstraint[];
+    mutuallyExclusive?: Array<{
+        fields: string[];
+        reason: string;
+    }>;
+    requireOneOf?: Array<{
+        fields: string[];
+        reason: string;
+    }>;
+}
+export declare const TOOL_CONSTRAINTS: OperationConstraint[];
+export interface ConstraintViolation {
+    field: string;
+    severity: ConstraintSeverity;
+    message: string;
+}
+export declare function validateOperation(operation_type: string, data: any): ConstraintViolation[];
+export declare function hasBlockingViolations(violations: ConstraintViolation[]): boolean;
+export declare function getWarningViolations(violations: ConstraintViolation[]): ConstraintViolation[];
+export declare const TOOL_CONSTRAINTS_VERSION = 1;

package/dist/knowledge/tool-constraints.js

@@ -0,0 +1,185 @@
+export const TOOL_CONSTRAINTS = [
+    {
+        operation_type: "service",
+        constraints: [
+            {
+                field: "namedNew.name",
+                description: "Service should have a name for easy reference",
+                severity: "warning",
+                check: (d) => !!d?.namedNew?.name || typeof d?.object === "string",
+                message: () => "Service without a name is hard to reference later. Consider setting namedNew.name.",
+            },
+            {
+                field: "price",
+                description: "Service price should be set before publish",
+                severity: "warning",
+                check: (d) => d?.price !== undefined || !d?.publish,
+                message: () => "Publishing a service without a price — customers won't know the cost.",
+            },
+        ],
+        requireOneOf: [
+            { fields: ["object", "namedNew"], reason: "Must specify either an existing object (string) or create new (namedNew)" },
+        ],
+    },
+    {
+        operation_type: "machine",
+        constraints: [
+            {
+                field: "node.nodes",
+                description: "Machine must have at least one node",
+                severity: "error",
+                check: (d) => Array.isArray(d?.node?.nodes) && d.node.nodes.length > 0,
+                message: () => "Machine has no nodes. A workflow template requires at least one node.",
+            },
+        ],
+    },
+    {
+        operation_type: "payment",
+        constraints: [
+            {
+                field: "revenue",
+                description: "Payment requires at least one revenue entry",
+                severity: "error",
+                check: (d) => Array.isArray(d?.revenue) && d.revenue.length > 0,
+                message: () => "Payment requires a non-empty 'revenue' array (payment recipients and amounts).",
+            },
+            {
+                field: "revenue[0].amount",
+                description: "Payment revenue amount must be specified",
+                severity: "error",
+                check: (d) => Array.isArray(d?.revenue) && d.revenue.length > 0 &&
+                    (!!d.revenue[0]?.amount?.balance || !!d.revenue[0]?.amount?.coin),
+                message: () => "Payment revenue[0].amount must specify either 'balance' value or 'coin' object (see CoinParamSchema).",
+            },
+        ],
+    },
+    {
+        operation_type: "order",
+        constraints: [
+            {
+                field: "service",
+                description: "Order must reference a service",
+                severity: "error",
+                check: (d) => !!d?.service,
+                message: () => "Order requires a 'service' field pointing to the service being ordered.",
+            },
+        ],
+    },
+    {
+        operation_type: "reward",
+        constraints: [
+            {
+                field: "coin_add",
+                description: "Reward funding requires coin_add",
+                severity: "warning",
+                check: (d) => {
+                    if (d?.claim || d?.guard_add || d?.guard_remove_expired || d?.owner_receive || d?.receive) {
+                        return true;
+                    }
+                    return !!d?.coin_add?.balance || !!d?.coin_add?.coin;
+                },
+                message: () => "Reward funding requires 'coin_add' with either 'balance' value or 'coin' object (see CoinParamSchema). Other operations (claim, guard_add, etc.) don't need coin_add.",
+            },
+        ],
+    },
+    {
+        operation_type: "guard",
+        constraints: [
+            {
+                field: "root",
+                description: "Guard must specify root (node tree or file)",
+                severity: "error",
+                check: (d) => !!d?.root,
+                message: () => "Guard requires a 'root' field (type='node' for tree or type='file' to load from file).",
+            },
+        ],
+    },
+    {
+        operation_type: "permission",
+        constraints: [
+            {
+                field: "with_forbidden",
+                description: "Permission should have at least one rule",
+                severity: "warning",
+                check: (d) => Array.isArray(d?.with_forbidden) && d.with_forbidden.length > 0 || Array.isArray(d?.with_allowed) && d.with_allowed.length > 0,
+                message: () => "Permission has no rules (with_forbidden/with_allowed). An empty permission allows nothing.",
+            },
+        ],
+    },
+    {
+        operation_type: "demand",
+        constraints: [
+            {
+                field: "reward",
+                description: "Demand should have a reward to attract solutions",
+                severity: "warning",
+                check: (d) => !!d?.reward,
+                message: () => "Demand without a reward pool may not attract solution providers.",
+            },
+        ],
+    },
+    {
+        operation_type: "progress",
+        constraints: [
+            {
+                field: "parent",
+                description: "Progress must reference a parent machine",
+                severity: "error",
+                check: (d) => !!d?.parent,
+                message: () => "Progress requires a 'parent' field pointing to the Machine.",
+            },
+        ],
+    },
+];
+const CONSTRAINT_INDEX = new Map(TOOL_CONSTRAINTS.map((c) => [c.operation_type, c]));
+export function validateOperation(operation_type, data) {
+    const constraint = CONSTRAINT_INDEX.get(operation_type);
+    if (!constraint)
+        return [];
+    const violations = [];
+    for (const c of constraint.constraints) {
+        try {
+            if (!c.check(data)) {
+                violations.push({
+                    field: c.field,
+                    severity: c.severity,
+                    message: c.message(data),
+                });
+            }
+        }
+        catch {
+        }
+    }
+    if (constraint.requireOneOf) {
+        for (const req of constraint.requireOneOf) {
+            const hasAtLeastOne = req.fields.some((f) => data?.[f] !== undefined && data?.[f] !== null);
+            if (!hasAtLeastOne) {
+                violations.push({
+                    field: req.fields.join("|"),
+                    severity: "error",
+                    message: req.reason,
+                });
+            }
+        }
+    }
+    if (constraint.mutuallyExclusive) {
+        for (const mex of constraint.mutuallyExclusive) {
+            const setFields = mex.fields.filter((f) => data?.[f] !== undefined && data?.[f] !== null);
+            if (setFields.length > 1) {
+                violations.push({
+                    field: setFields.join("|"),
+                    severity: "error",
+                    message: `Fields are mutually exclusive: ${setFields.join(", ")}. ${mex.reason}`,
+                });
+            }
+        }
+    }
+    return violations;
+}
+export function hasBlockingViolations(violations) {
+    return violations.some((v) => v.severity === "error");
+}
+export function getWarningViolations(violations) {
+    return violations.filter((v) => v.severity === "warning");
+}
+export const TOOL_CONSTRAINTS_VERSION = 1;

package/dist/knowledge/trust-metrics.d.ts

@@ -0,0 +1,37 @@
+export interface ServiceTrustMetrics {
+    arbitrationScore?: number;
+    arbitrationCases?: number;
+    reviewStats?: {
+        likes: number;
+        dislikes: number;
+        verifiedReviews: number;
+        totalReviews: number;
+    };
+    orderCount?: number;
+    completedRate?: number;
+    avgCompletionTime?: number;
+    compensationFundBalance?: bigint;
+    hasPublishedEvents?: boolean;
+    hasMachineBound?: boolean;
+    hasBuyGuard?: boolean;
+}
+export interface TrustDimension {
+    name: string;
+    score: number;
+    maxScore: number;
+    description: string;
+    humanReadable: string;
+}
+export interface ServiceTrustScore {
+    score: number;
+    level: "high_risk" | "caution" | "moderate" | "trusted";
+    breakdown: TrustDimension[];
+    summary: string;
+    warnings: string[];
+}
+export declare const TRUST_METRICS_VERSION = 1;
+export declare function computeServiceTrustScore(metrics: ServiceTrustMetrics): ServiceTrustScore;
+export declare function quickTrustCheck(metrics: ServiceTrustMetrics): {
+    pass: boolean;
+    reason: string;
+};

package/dist/knowledge/trust-metrics.js

@@ -0,0 +1,138 @@
+export const TRUST_METRICS_VERSION = 1;
+const TRUST_LEVELS = [
+    { min: 75, level: "trusted", label: "高信任" },
+    { min: 50, level: "moderate", label: "中等信任" },
+    { min: 25, level: "caution", label: "需注意" },
+    { min: 0, level: "high_risk", label: "高风险" },
+];
+export function computeServiceTrustScore(metrics) {
+    const breakdown = [];
+    const warnings = [];
+    const arbScore = computeArbitrationDimension(metrics);
+    breakdown.push(arbScore);
+    if (arbScore.score < arbScore.maxScore * 0.3) {
+        warnings.push("仲裁信任分较低，建议检查仲裁记录");
+    }
+    const reviewScore = computeReviewDimension(metrics);
+    breakdown.push(reviewScore);
+    if (reviewScore.score < reviewScore.maxScore * 0.3 && metrics.reviewStats) {
+        warnings.push(`好评率较低 (${metrics.reviewStats.likes}/${metrics.reviewStats.totalReviews})`);
+    }
+    const fulfillmentScore = computeFulfillmentDimension(metrics);
+    breakdown.push(fulfillmentScore);
+    if (metrics.completedRate !== undefined && metrics.completedRate < 0.7) {
+        warnings.push(`完成率仅 ${Math.round(metrics.completedRate * 100)}%`);
+    }
+    const fundScore = computeFundDimension(metrics);
+    breakdown.push(fundScore);
+    if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
+        warnings.push("无赔偿金，客户权益保障不足");
+    }
+    const transparencyScore = computeTransparencyDimension(metrics);
+    breakdown.push(transparencyScore);
+    const totalScore = breakdown.reduce((sum, d) => sum + d.score, 0);
+    const level = TRUST_LEVELS.find((l) => totalScore >= l.min)?.level ?? "high_risk";
+    const label = TRUST_LEVELS.find((l) => totalScore >= l.min)?.label ?? "高风险";
+    const summary = buildSummary(totalScore, label, metrics, breakdown);
+    return { score: totalScore, level, breakdown, summary, warnings };
+}
+function computeArbitrationDimension(metrics) {
+    const maxScore = 30;
+    if (metrics.arbitrationScore === undefined) {
+        return { name: "arbitration", score: maxScore * 0.5, maxScore, description: "仲裁信任分（无数据，默认中等）", humanReadable: "仲裁记录: 无数据" };
+    }
+    const score = Math.round((metrics.arbitrationScore / 100) * maxScore);
+    return {
+        name: "arbitration",
+        score,
+        maxScore,
+        description: `仲裁信任分 ${metrics.arbitrationScore}/100`,
+        humanReadable: `仲裁信任: ${metrics.arbitrationScore}/100${metrics.arbitrationCases !== undefined ? ` (${metrics.arbitrationCases} 案件)` : ""}`,
+    };
+}
+function computeReviewDimension(metrics) {
+    const maxScore = 25;
+    if (!metrics.reviewStats || metrics.reviewStats.totalReviews === 0) {
+        return { name: "reviews", score: maxScore * 0.5, maxScore, description: "评价声誉（无评价数据）", humanReadable: "评价: 无数据" };
+    }
+    const { likes, dislikes, verifiedReviews, totalReviews } = metrics.reviewStats;
+    const likeRate = likes / Math.max(1, totalReviews);
+    const verifiedBoost = Math.min(5, verifiedReviews);
+    const score = Math.round(likeRate * (maxScore - 5) + verifiedBoost);
+    return {
+        name: "reviews",
+        score: Math.min(maxScore, score),
+        maxScore,
+        description: `好评率 ${Math.round(likeRate * 100)}% (${totalReviews} 条评价, ${verifiedReviews} 条带凭证)`,
+        humanReadable: `好评率 ${Math.round(likeRate * 100)}% (${totalReviews} 评价)`,
+    };
+}
+function computeFulfillmentDimension(metrics) {
+    const maxScore = 20;
+    if (metrics.orderCount === undefined) {
+        return { name: "fulfillment", score: maxScore * 0.5, maxScore, description: "履约记录（无订单数据）", humanReadable: "履约: 无数据" };
+    }
+    let score = 0;
+    const orderScore = Math.min(10, Math.floor(metrics.orderCount / 5));
+    score += orderScore;
+    if (metrics.completedRate !== undefined) {
+        score += Math.round(metrics.completedRate * 10);
+    }
+    else {
+        score += 5;
+    }
+    return {
+        name: "fulfillment",
+        score: Math.min(maxScore, score),
+        maxScore,
+        description: `已完成 ${metrics.orderCount} 单, 完成率 ${metrics.completedRate !== undefined ? Math.round(metrics.completedRate * 100) + "%" : "未知"}`,
+        humanReadable: `履约: ${metrics.orderCount} 单${metrics.avgCompletionTime !== undefined ? `, 平均 ${metrics.avgCompletionTime}h` : ""}`,
+    };
+}
+function computeFundDimension(metrics) {
+    const maxScore = 15;
+    if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
+        return { name: "fund_safety", score: 0, maxScore, description: "无赔偿金", humanReadable: "赔偿金: 无" };
+    }
+    const threshold = 1000000000000n;
+    const ratio = Number(metrics.compensationFundBalance * 100n / threshold) / 100;
+    const score = Math.min(maxScore, Math.round(ratio * maxScore));
+    return {
+        name: "fund_safety",
+        score,
+        maxScore,
+        description: `赔偿金 ${metrics.compensationFundBalance} 最小单位`,
+        humanReadable: `赔偿金: 充足`,
+    };
+}
+function computeTransparencyDimension(metrics) {
+    const maxScore = 10;
+    let score = 0;
+    if (metrics.hasPublishedEvents)
+        score += 4;
+    if (metrics.hasMachineBound)
+        score += 3;
+    if (metrics.hasBuyGuard)
+        score += 3;
+    return {
+        name: "transparency",
+        score: Math.min(maxScore, score),
+        maxScore,
+        description: `链上事件 ${metrics.hasPublishedEvents ? "✓" : "✗"}, Machine ${metrics.hasMachineBound ? "✓" : "✗"}, Guard ${metrics.hasBuyGuard ? "✓" : "✗"}`,
+        humanReadable: `透明度: ${["事件", "Machine", "Guard"].filter((_, i) => [metrics.hasPublishedEvents, metrics.hasMachineBound, metrics.hasBuyGuard][i]).join("+") || "无"}`,
+    };
+}
+function buildSummary(score, label, metrics, breakdown) {
+    const parts = [`信任分 ${score}/100 (${label})`];
+    for (const d of breakdown) {
+        parts.push(`${d.humanReadable}`);
+    }
+    return parts.join("; ");
+}
+export function quickTrustCheck(metrics) {
+    const result = computeServiceTrustScore(metrics);
+    if (result.score < 25) {
+        return { pass: false, reason: `信任分 ${result.score}/100，高风险: ${result.warnings.join("; ")}` };
+    }
+    return { pass: true, reason: `信任分 ${result.score}/100 (${result.level})` };
+}

package/dist/loop-engineering/diagnose.d.ts

@@ -1,5 +1,5 @@
 import type { AggregatedStats } from "./aggregate.js";
-export type DiagnosisType = "rule_gap" | "description_quality" | "skill_need" | "recovery_ineffectiveness" | "latency_anomaly";
+export type DiagnosisType = "rule_gap" | "description_quality" | "skill_need" | "recovery_ineffectiveness" | "latency_anomaly" | "industry_health_anomaly";
 export type DiagnosisSeverity = "P0" | "P1" | "P2" | "P3";
 export interface Diagnosis {
     diagnosis_id: string;
@@ -9,7 +9,7 @@ export interface Diagnosis {
     description: string;
     evidence: Record<string, unknown>;
     target: string;
-    proposed_improvement_type: "rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation";
+    proposed_improvement_type: "rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation" | "industry_update_application";
 }
 export interface DiagnosisReport {
     report_id: string;
@@ -18,4 +18,5 @@ export interface DiagnosisReport {
     diagnoses: Diagnosis[];
     summary: string;
 }
+export declare function diagnoseIndustryHealth(industries?: string[]): Diagnosis[];
 export declare function diagnose(stats: AggregatedStats): DiagnosisReport;

package/dist/loop-engineering/diagnose.js

@@ -1,3 +1,4 @@
+import { listIndustriesWithSignals, getIndustryEvolutionStatus, getPendingSuggestions, getIndustrySignalCount, } from "../knowledge/flywheel-loop.js";
 const THRESHOLDS = {
     UNKNOWN_ERROR_RATE_P0: 0.15,
     UNKNOWN_ERROR_RATE_P1: 0.08,
@@ -154,6 +155,98 @@ function diagnoseLatencyAnomalies(stats) {
     }
     return diagnoses;
 }
+const INDUSTRY_HEALTH_THRESHOLDS = {
+    CRITICAL_HEALTH_SCORE: 45,
+    STRESSED_HEALTH_SCORE: 65,
+    HIGH_PENDING_SUGGESTIONS: 3,
+    STALE_SIGNAL_THRESHOLD: 20,
+};
+export function diagnoseIndustryHealth(industries) {
+    const targets = industries ?? listIndustriesWithSignals();
+    const diagnoses = [];
+    for (const industry of targets) {
+        const status = getIndustryEvolutionStatus(industry);
+        const pendingDetail = getPendingSuggestions(industry);
+        const signalCount = getIndustrySignalCount(industry);
+        if (status.health) {
+            const score = status.health.health_score;
+            if (score < INDUSTRY_HEALTH_THRESHOLDS.CRITICAL_HEALTH_SCORE) {
+                diagnoses.push({
+                    diagnosis_id: `DIAG-IND-${Date.now()}-${industry}-critical`,
+                    type: "industry_health_anomaly",
+                    severity: "P0",
+                    title: `Industry '${industry}' health critical (${score}/100, ${status.health.level})`,
+                    description: `Industry health score is in the danger zone. Weaknesses: ${status.health.weaknesses.join("; ") || "none"}. Recommendations: ${status.health.recommendations.join("; ") || "none"}.`,
+                    evidence: {
+                        industry,
+                        health_score: score,
+                        health_level: status.health.level,
+                        weaknesses: status.health.weaknesses,
+                        recommendations: status.health.recommendations,
+                        signal_count: signalCount,
+                    },
+                    target: `industry:${industry}`,
+                    proposed_improvement_type: "industry_update_application",
+                });
+            }
+            else if (score < INDUSTRY_HEALTH_THRESHOLDS.STRESSED_HEALTH_SCORE) {
+                diagnoses.push({
+                    diagnosis_id: `DIAG-IND-${Date.now()}-${industry}-stressed`,
+                    type: "industry_health_anomaly",
+                    severity: "P1",
+                    title: `Industry '${industry}' health stressed (${score}/100, ${status.health.level})`,
+                    description: `Industry health score is under pressure. Weaknesses: ${status.health.weaknesses.join("; ") || "none"}.`,
+                    evidence: {
+                        industry,
+                        health_score: score,
+                        health_level: status.health.level,
+                        weaknesses: status.health.weaknesses,
+                        signal_count: signalCount,
+                    },
+                    target: `industry:${industry}`,
+                    proposed_improvement_type: "industry_update_application",
+                });
+            }
+        }
+        if (pendingDetail.length >= INDUSTRY_HEALTH_THRESHOLDS.HIGH_PENDING_SUGGESTIONS) {
+            const highPriority = pendingDetail.filter((s) => s.priority === "high");
+            diagnoses.push({
+                diagnosis_id: `DIAG-IND-${Date.now()}-${industry}-pending`,
+                type: "industry_health_anomaly",
+                severity: highPriority.length > 0 ? "P1" : "P2",
+                title: `Industry '${industry}' has ${pendingDetail.length} pending suggestions (${highPriority.length} high priority)`,
+                description: `Industry has ${pendingDetail.length} pending evolution suggestions unprocessed. Review and apply promptly to drive industry evolution.`,
+                evidence: {
+                    industry,
+                    pending_count: pendingDetail.length,
+                    high_priority_count: highPriority.length,
+                    suggestion_types: pendingDetail.map((s) => s.suggestion_type),
+                    suggestion_summaries: pendingDetail.map((s) => ({ type: s.suggestion_type, field: s.field, priority: s.priority })),
+                },
+                target: `industry:${industry}:pending_suggestions`,
+                proposed_improvement_type: "industry_update_application",
+            });
+        }
+        if (signalCount >= INDUSTRY_HEALTH_THRESHOLDS.STALE_SIGNAL_THRESHOLD && !status.health) {
+            diagnoses.push({
+                diagnosis_id: `DIAG-IND-${Date.now()}-${industry}-stale`,
+                type: "industry_health_anomaly",
+                severity: "P2",
+                title: `Industry '${industry}' has ${signalCount} signals but no health report (evolution stale)`,
+                description: `Industry has accumulated ${signalCount} signals but health score has not been recalculated. May need to manually trigger updateIndustryCognition or check scheduling configuration.`,
+                evidence: {
+                    industry,
+                    signal_count: signalCount,
+                    evolution_ready: status.evolution_ready,
+                    version: status.version,
+                },
+                target: `industry:${industry}:cognition`,
+                proposed_improvement_type: "industry_update_application",
+            });
+        }
+    }
+    return diagnoses;
+}
 export function diagnose(stats) {
     const all = [
         ...diagnoseRuleGaps(stats),
@@ -161,6 +254,7 @@ export function diagnose(stats) {
         ...diagnoseSkillNeeds(stats),
         ...diagnoseRecoveryIneffectiveness(stats),
         ...diagnoseLatencyAnomalies(stats),
+        ...diagnoseIndustryHealth(),
     ];
     const severityOrder = { P0: 0, P1: 1, P2: 2, P3: 3 };
     all.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);

package/dist/loop-engineering/improve.d.ts

@@ -1,5 +1,5 @@
 import type { DiagnosisReport } from "./diagnose.js";
-export type ProposalType = "error_rule_addition" | "intent_rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation";
+export type ProposalType = "error_rule_addition" | "intent_rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation" | "industry_update_application";
 export type AutomationLevel = "full" | "semi" | "manual";
 export interface ImprovementProposal {
     proposal_id: string;

package/dist/loop-engineering/improve.js

@@ -1,3 +1,4 @@
+import { getPendingSuggestions } from "../knowledge/flywheel-loop.js";
 function proposeErrorRuleAddition(diagnosis) {
     const evidence = diagnosis.evidence;
     const topMessages = evidence.top_error_messages || [];
@@ -54,7 +55,7 @@ function proposeDescriptionRewrite(diagnosis) {
             current_semantic_hit_rate: evidence.semantic_hit_rate,
             target_semantic_hit_rate: 0.80,
             rewrite_guidelines: [
-                "Follow 4-part format: 含义 + Constraint + Relation + Example",
+                "Follow 4-part format: Meaning + Constraint + Relation + Example",
                 "Add explicit intent signals to INTENT_RULES",
                 "Include concrete examples for common operation types",
             ],
@@ -139,6 +140,53 @@ function proposeInvestigation(diagnosis) {
         ab_test_recommended: false,
     };
 }
+function proposeIndustryUpdate(diagnosis) {
+    const evidence = diagnosis.evidence;
+    const industry = evidence.industry ?? diagnosis.target.split(":")[1] ?? "unknown";
+    const pendingSuggestions = industry !== "unknown"
+        ? getPendingSuggestions(industry)
+        : [];
+    const changes = pendingSuggestions.map((s) => ({
+        suggestion_type: s.suggestion_type,
+        field: s.field,
+        suggested_value: s.suggested_value,
+        evidence: s.evidence,
+        confidence: s.confidence,
+        priority: s.priority,
+    }));
+    const isHealthCritical = evidence.health_score !== undefined && evidence.health_score < 45;
+    const hasHighPrioritySuggestions = (evidence.high_priority_count ?? 0) > 0;
+    return {
+        proposal_id: `PROP-IND-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        source_diagnosis_id: diagnosis.diagnosis_id,
+        type: "industry_update_application",
+        priority: diagnosis.severity,
+        automation: isHealthCritical ? "semi" : "manual",
+        title: `Apply ${pendingSuggestions.length} evolution suggestions for industry '${industry}'`,
+        description: `Industry '${industry}' has health anomaly (health score ${evidence.health_score ?? "N/A"}, level ${evidence.health_level ?? "N/A"}). ` +
+            `Has ${pendingSuggestions.length} pending evolution suggestions (${(evidence.high_priority_count ?? 0)} high priority). ` +
+            `Review and apply to drive industry cognition evolution. Weaknesses: ${(evidence.weaknesses ?? []).join("; ") || "none"}.`,
+        target: `industry:${industry}`,
+        proposed_change: {
+            action: "apply_industry_updates",
+            industry,
+            current_health_score: evidence.health_score,
+            current_health_level: evidence.health_level,
+            weaknesses: evidence.weaknesses ?? [],
+            recommendations: evidence.recommendations ?? [],
+            pending_suggestion_count: pendingSuggestions.length,
+            high_priority_count: evidence.high_priority_count ?? 0,
+            suggestions: changes,
+            auto_applicable_suggestions: changes.filter((c) => c.confidence >= 0.85 && c.priority === "high"),
+            apply_guidance: hasHighPrioritySuggestions
+                ? "Prioritize reviewing high-priority suggestions; high-confidence (≥0.85) suggestions can be semi-automatically applied"
+                : "No high-priority suggestions, review via normal process",
+        },
+        evidence: diagnosis.evidence,
+        review_status: "pending",
+        ab_test_recommended: false,
+    };
+}
 export function generateImprovements(report) {
     const proposals = [];
     for (const diagnosis of report.diagnoses) {
@@ -156,6 +204,9 @@ export function generateImprovements(report) {
             case "recovery_priority_adjustment":
                 proposal = proposeRecoveryAdjustment(diagnosis);
                 break;
+            case "industry_update_application":
+                proposal = proposeIndustryUpdate(diagnosis);
+                break;
             default:
                 proposal = proposeInvestigation(diagnosis);
         }