@wowok/agent-mcp 2.6.0 → 2.6.3

package/dist/extensions/constraint-registry.js

@@ -0,0 +1,196 @@
+const BUILTIN_CONSTRAINTS = [
+    {
+        constraint_id: "require_arbitration",
+        display_name: "Require Arbitration",
+        description: "Mode must include arbitration capability (arb.*) for dispute resolution",
+        rule: { type: "capability_required", capability_id: "arb.vote_weighted" },
+        severity: "hard",
+        on_violation: "block",
+        scope: "builtin",
+    },
+    {
+        constraint_id: "require_compensation_fund",
+        display_name: "Require Compensation Fund",
+        description: "Mode must include fund escrow capability (treasury.*) for compensation fund",
+        rule: { type: "capability_required", capability_id: "treasury.owner_receive" },
+        severity: "hard",
+        on_violation: "block",
+        scope: "builtin",
+    },
+    {
+        constraint_id: "require_wip_evidence",
+        display_name: "Require WIP Evidence",
+        description: "Mode must include WIP evidence capability (guard.validate_wip_hash) for digital delivery validation",
+        rule: { type: "capability_required", capability_id: "guard.validate_wip_hash" },
+        severity: "soft",
+        on_violation: "warn",
+        scope: "builtin",
+    },
+    {
+        constraint_id: "max_single_transaction_limit",
+        display_name: "Single Transaction Limit",
+        description: "Single transaction amount must not exceed 10000 WOW (default value, can be overridden by mode)",
+        rule: { type: "numeric_limit", field: "max_single_transaction", max: 10000 },
+        severity: "soft",
+        on_violation: "warn",
+        scope: "builtin",
+    },
+];
+export class ConstraintRegistry {
+    static instance;
+    constraints = new Map();
+    initialized = false;
+    static Instance() {
+        if (!ConstraintRegistry.instance) {
+            ConstraintRegistry.instance = new ConstraintRegistry();
+        }
+        return ConstraintRegistry.instance;
+    }
+    constructor() {
+        this.registerBuiltinConstraints();
+        this.initialized = true;
+    }
+    registerConstraint(constraint) {
+        if (!constraint.constraint_id || !constraint.rule)
+            return false;
+        if (this.constraints.has(constraint.constraint_id))
+            return false;
+        this.constraints.set(constraint.constraint_id, constraint);
+        return true;
+    }
+    registerCustomConstraint(constraint_id, display_name, description, rule, owner, severity = "soft", on_violation = "warn") {
+        return this.registerConstraint({
+            constraint_id,
+            display_name,
+            description,
+            rule,
+            severity,
+            on_violation,
+            scope: "custom",
+            owner,
+        });
+    }
+    getConstraint(constraint_id) {
+        return this.constraints.get(constraint_id);
+    }
+    listConstraints(filter) {
+        let all = Array.from(this.constraints.values());
+        if (!filter)
+            return all;
+        if (filter.scope)
+            all = all.filter(c => c.scope === filter.scope);
+        if (filter.owner)
+            all = all.filter(c => c.owner === filter.owner);
+        if (filter.severity)
+            all = all.filter(c => c.severity === filter.severity);
+        return all;
+    }
+    unregisterConstraint(constraint_id, owner) {
+        const constraint = this.constraints.get(constraint_id);
+        if (!constraint || constraint.scope !== "custom" || constraint.owner !== owner)
+            return false;
+        return this.constraints.delete(constraint_id);
+    }
+    checkConstraints(mode, _capabilityRegistry, extraConstraints) {
+        const allConstraints = [...this.constraints.values()];
+        if (extraConstraints) {
+            for (const c of extraConstraints) {
+                if (!allConstraints.some(existing => existing.constraint_id === c.constraint_id)) {
+                    allConstraints.push(c);
+                }
+            }
+        }
+        const violations = [];
+        for (const constraint of allConstraints) {
+            const violation = this.checkConstraint(mode, constraint);
+            if (violation) {
+                violations.push(violation);
+            }
+        }
+        return violations;
+    }
+    checkConstraint(mode, constraint) {
+        const rule = constraint.rule;
+        switch (rule.type) {
+            case "capability_required": {
+                if (!mode.capabilities_used.includes(rule.capability_id)) {
+                    return {
+                        constraint_id: constraint.constraint_id,
+                        display_name: constraint.display_name,
+                        violation: `Missing required capability: ${rule.capability_id}`,
+                        severity: constraint.severity,
+                        action: constraint.on_violation,
+                        recommendation: `Add "${rule.capability_id}" to capabilities_used`,
+                    };
+                }
+                return null;
+            }
+            case "capability_forbidden": {
+                if (mode.capabilities_used.includes(rule.capability_id)) {
+                    return {
+                        constraint_id: constraint.constraint_id,
+                        display_name: constraint.display_name,
+                        violation: `Contains forbidden capability: ${rule.capability_id}`,
+                        severity: constraint.severity,
+                        action: constraint.on_violation,
+                        recommendation: `Remove "${rule.capability_id}" from capabilities_used`,
+                    };
+                }
+                return null;
+            }
+            case "numeric_limit": {
+                const fieldValue = this.getNumericField(mode, rule.field);
+                if (fieldValue === undefined)
+                    return null;
+                if (rule.max !== undefined && fieldValue > rule.max) {
+                    return {
+                        constraint_id: constraint.constraint_id,
+                        display_name: constraint.display_name,
+                        violation: `${rule.field}=${fieldValue} exceeds upper limit ${rule.max}`,
+                        severity: constraint.severity,
+                        action: constraint.on_violation,
+                        recommendation: `Reduce ${rule.field} below ${rule.max}`,
+                    };
+                }
+                if (rule.min !== undefined && fieldValue < rule.min) {
+                    return {
+                        constraint_id: constraint.constraint_id,
+                        display_name: constraint.display_name,
+                        violation: `${rule.field}=${fieldValue} below lower limit ${rule.min}`,
+                        severity: constraint.severity,
+                        action: constraint.on_violation,
+                        recommendation: `Increase ${rule.field} above ${rule.min}`,
+                    };
+                }
+                return null;
+            }
+            case "condition_required": {
+                return {
+                    constraint_id: constraint.constraint_id,
+                    display_name: constraint.display_name,
+                    violation: `Natural language condition pending AI evaluation: "${rule.condition}"`,
+                    severity: constraint.severity,
+                    action: constraint.on_violation,
+                    recommendation: `Please have AI evaluate whether this condition is satisfied, and update the mode configuration`,
+                };
+            }
+            default:
+                return null;
+        }
+    }
+    getNumericField(mode, field) {
+        if (field === "max_single_transaction") {
+            return mode.risk_constraints.max_single_transaction;
+        }
+        return undefined;
+    }
+    registerBuiltinConstraints() {
+        for (const constraint of BUILTIN_CONSTRAINTS) {
+            this.registerConstraint(constraint);
+        }
+    }
+}
+export function getConstraintRegistry() {
+    return ConstraintRegistry.Instance();
+}
+export const BUILTIN_CONSTRAINTS_COUNT = BUILTIN_CONSTRAINTS.length;

package/dist/extensions/index.d.ts

@@ -0,0 +1,12 @@
+export type { Blueprint, BlueprintObject, BlueprintEdge, BlueprintStep, BlueprintScenario, ProjectContext, } from "./types.js";
+export type { IndustryMode, IndustryModeRegistration, UserDefinedMode, DeriveModeOptions, EvolveModeOptions, } from "./types.js";
+export type { ExpectedBenefit, RiskAppetite, ModeRiskConstraints, ModeApplicableConditions, ConfigOverrideRule, ModeEvaluation, ModeMigrationEvaluation, } from "./types.js";
+export type { BaseMetric, MetricType, MetricScale, MetricValue, CapabilityMetricValue, MetricEvaluation, } from "./types.js";
+export type { ModeConstraint, ConstraintRule, ConstraintSeverity, ConstraintViolationAction, ConstraintViolation, } from "./types.js";
+export { CapabilityRegistry, getCapabilityRegistry, recordCapabilitiesUsed, CAPABILITY_MANIFEST_VERSION, } from "./capability-manifest.js";
+export type { CapabilityCard, CapabilityGraph, CapabilityGraphEdge, CapabilityModule, CapabilityCategory, IndustryAgnostic, MigrationEvaluation, CoverageReport, ExperienceUpdate, VerificationReport, CapabilityRiskProfile, CapabilityBenefitProfile, CapabilityConstraints, } from "./capability-manifest.js";
+export { IndustryModeRegistry, getIndustryModeRegistry, INDUSTRY_MODE_REGISTRY_VERSION, } from "./registry.js";
+export { MetricRegistry, getMetricRegistry, BUILTIN_METRICS_COUNT, } from "./metric-registry.js";
+export { ConstraintRegistry, getConstraintRegistry, BUILTIN_CONSTRAINTS_COUNT, } from "./constraint-registry.js";
+export { ModeEvaluator } from "./mode-evaluator.js";
+export { BUILTIN_MODES } from "./modes.js";

package/dist/extensions/index.js

@@ -0,0 +1,6 @@
+export { CapabilityRegistry, getCapabilityRegistry, recordCapabilitiesUsed, CAPABILITY_MANIFEST_VERSION, } from "./capability-manifest.js";
+export { IndustryModeRegistry, getIndustryModeRegistry, INDUSTRY_MODE_REGISTRY_VERSION, } from "./registry.js";
+export { MetricRegistry, getMetricRegistry, BUILTIN_METRICS_COUNT, } from "./metric-registry.js";
+export { ConstraintRegistry, getConstraintRegistry, BUILTIN_CONSTRAINTS_COUNT, } from "./constraint-registry.js";
+export { ModeEvaluator } from "./mode-evaluator.js";
+export { BUILTIN_MODES } from "./modes.js";

package/dist/extensions/metric-registry.d.ts

@@ -0,0 +1,26 @@
+import type { BaseMetric, MetricType, MetricScale, MetricEvaluation, IndustryMode } from "./types.js";
+import type { CapabilityRegistry } from "./capability-manifest.js";
+export declare class MetricRegistry {
+    private static instance;
+    private metrics;
+    private initialized;
+    static Instance(): MetricRegistry;
+    private constructor();
+    registerMetric(metric: BaseMetric): boolean;
+    registerCustomMetric(metric_id: string, display_name: string, description: string, type: MetricType, scale: MetricScale, owner: string, weight?: number): boolean;
+    getMetric(metric_id: string): BaseMetric | undefined;
+    listMetrics(filter?: {
+        type?: MetricType;
+        scope?: "builtin" | "custom";
+        owner?: string;
+    }): BaseMetric[];
+    unregisterMetric(metric_id: string, owner: string): boolean;
+    evaluateMode(mode: IndustryMode, capabilityRegistry: CapabilityRegistry, extraMetrics?: BaseMetric[]): MetricEvaluation;
+    private evaluateMetricGroup;
+    private computeAverageScore;
+    private aggregateValue;
+    private aggregateScore;
+    private registerBuiltinMetrics;
+}
+export declare function getMetricRegistry(): MetricRegistry;
+export declare const BUILTIN_METRICS_COUNT: number;

package/dist/extensions/metric-registry.js

@@ -0,0 +1,257 @@
+const LEVEL_WEIGHT = {
+    high: 1.0,
+    medium: 0.6,
+    low: 0.3,
+};
+const BUILTIN_RISK_METRICS = [
+    {
+        metric_id: "funds_risk",
+        display_name: "Funds Risk",
+        description: "Directly operates funds / affects fund flow / no fund risk",
+        type: "risk",
+        scale: "level",
+        weight: 1.0,
+        scope: "builtin",
+    },
+    {
+        metric_id: "trust_risk",
+        display_name: "Trust Risk",
+        description: "Degree of impact on trust mechanism",
+        type: "risk",
+        scale: "level",
+        weight: 1.0,
+        scope: "builtin",
+    },
+    {
+        metric_id: "delivery_risk",
+        display_name: "Delivery Risk",
+        description: "Degree of impact on order fulfillment",
+        type: "risk",
+        scale: "level",
+        weight: 1.0,
+        scope: "builtin",
+    },
+    {
+        metric_id: "compliance_risk",
+        display_name: "Compliance Risk",
+        description: "Degree of regulatory involvement",
+        type: "risk",
+        scale: "level",
+        weight: 1.0,
+        scope: "builtin",
+    },
+];
+const BUILTIN_BENEFIT_METRICS = [
+    {
+        metric_id: "automation_level",
+        display_name: "Automation Level",
+        description: "Fully automated / semi-automated / manual",
+        type: "benefit",
+        scale: "level",
+        weight: 1.0,
+        scope: "builtin",
+    },
+    {
+        metric_id: "trust_boost",
+        display_name: "Trust Boost",
+        description: "Degree of enhancement to trust mechanism",
+        type: "benefit",
+        scale: "level",
+        weight: 1.0,
+        scope: "builtin",
+    },
+    {
+        metric_id: "efficiency_gain",
+        display_name: "Efficiency Gain",
+        description: "Degree of efficiency improvement",
+        type: "benefit",
+        scale: "level",
+        weight: 1.0,
+        scope: "builtin",
+    },
+];
+export class MetricRegistry {
+    static instance;
+    metrics = new Map();
+    initialized = false;
+    static Instance() {
+        if (!MetricRegistry.instance) {
+            MetricRegistry.instance = new MetricRegistry();
+        }
+        return MetricRegistry.instance;
+    }
+    constructor() {
+        this.registerBuiltinMetrics();
+        this.initialized = true;
+    }
+    registerMetric(metric) {
+        if (!metric.metric_id || !metric.type || !metric.scale)
+            return false;
+        if (this.metrics.has(metric.metric_id))
+            return false;
+        this.metrics.set(metric.metric_id, metric);
+        return true;
+    }
+    registerCustomMetric(metric_id, display_name, description, type, scale, owner, weight) {
+        return this.registerMetric({
+            metric_id,
+            display_name,
+            description,
+            type,
+            scale,
+            weight: weight ?? 1.0,
+            scope: "custom",
+            owner,
+        });
+    }
+    getMetric(metric_id) {
+        return this.metrics.get(metric_id);
+    }
+    listMetrics(filter) {
+        let all = Array.from(this.metrics.values());
+        if (!filter)
+            return all;
+        if (filter.type)
+            all = all.filter(m => m.type === filter.type);
+        if (filter.scope)
+            all = all.filter(m => m.scope === filter.scope);
+        if (filter.owner)
+            all = all.filter(m => m.owner === filter.owner);
+        return all;
+    }
+    unregisterMetric(metric_id, owner) {
+        const metric = this.metrics.get(metric_id);
+        if (!metric || metric.scope !== "custom" || metric.owner !== owner)
+            return false;
+        return this.metrics.delete(metric_id);
+    }
+    evaluateMode(mode, capabilityRegistry, extraMetrics) {
+        const allMetrics = [...this.metrics.values()];
+        if (extraMetrics) {
+            for (const m of extraMetrics) {
+                if (!allMetrics.some(existing => existing.metric_id === m.metric_id)) {
+                    allMetrics.push(m);
+                }
+            }
+        }
+        const riskMetrics = allMetrics.filter(m => m.type === "risk");
+        const benefitMetrics = allMetrics.filter(m => m.type === "benefit");
+        const cards = [];
+        for (const capId of mode.capabilities_used) {
+            const card = capabilityRegistry.getCard(capId);
+            if (card)
+                cards.push(card);
+        }
+        const risk_details = this.evaluateMetricGroup(cards, riskMetrics, "risk");
+        const benefit_details = this.evaluateMetricGroup(cards, benefitMetrics, "benefit");
+        const risk_score = this.aggregateScore(risk_details);
+        const benefit_score = this.aggregateScore(benefit_details);
+        return {
+            risk_score,
+            benefit_score,
+            metric_details: [...risk_details, ...benefit_details],
+        };
+    }
+    evaluateMetricGroup(cards, metrics, type) {
+        const details = [];
+        for (const metric of metrics) {
+            const values = [];
+            for (const card of cards) {
+                const profile = type === "risk" ? card.risk_profile : card.benefit_profile;
+                if (!profile)
+                    continue;
+                const fieldValue = profile[metric.metric_id];
+                if (fieldValue !== undefined) {
+                    values.push({
+                        value: fieldValue,
+                        weight: 1.0,
+                    });
+                }
+            }
+            if (values.length === 0)
+                continue;
+            const avgScore = this.computeAverageScore(values, metric.scale);
+            details.push({
+                metric_id: metric.metric_id,
+                display_name: metric.display_name,
+                value: this.aggregateValue(values, metric.scale),
+                normalized_score: avgScore,
+                weight: metric.weight ?? 1.0,
+            });
+        }
+        return details;
+    }
+    computeAverageScore(values, scale) {
+        if (values.length === 0)
+            return 0;
+        if (scale === "level") {
+            const levelToScore = { high: 100, medium: 60, low: 30 };
+            let total = 0;
+            let weightSum = 0;
+            for (const v of values) {
+                const score = levelToScore[String(v.value)] ?? 50;
+                total += score * v.weight;
+                weightSum += v.weight;
+            }
+            return Math.round(total / Math.max(weightSum, 1));
+        }
+        if (scale === "numeric") {
+            let total = 0;
+            let weightSum = 0;
+            for (const v of values) {
+                const numValue = typeof v.value === "number" ? v.value : 50;
+                total += numValue * v.weight;
+                weightSum += v.weight;
+            }
+            return Math.round(total / Math.max(weightSum, 1));
+        }
+        if (scale === "percentage") {
+            let total = 0;
+            let weightSum = 0;
+            for (const v of values) {
+                const pctValue = typeof v.value === "number" ? v.value : 50;
+                total += pctValue * v.weight;
+                weightSum += v.weight;
+            }
+            return Math.round(total / Math.max(weightSum, 1));
+        }
+        return 0;
+    }
+    aggregateValue(values, scale) {
+        if (scale === "level") {
+            const counts = { high: 0, medium: 0, low: 0 };
+            for (const v of values) {
+                const key = String(v.value);
+                if (counts[key] !== undefined)
+                    counts[key]++;
+            }
+            const maxKey = Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0];
+            return maxKey ?? "medium";
+        }
+        const sum = values.reduce((acc, v) => acc + (typeof v.value === "number" ? v.value : 0), 0);
+        return Math.round(sum / values.length);
+    }
+    aggregateScore(details) {
+        if (details.length === 0)
+            return 0;
+        let total = 0;
+        let weightSum = 0;
+        for (const d of details) {
+            total += d.normalized_score * d.weight;
+            weightSum += d.weight;
+        }
+        return Math.round(total / Math.max(weightSum, 1));
+    }
+    registerBuiltinMetrics() {
+        for (const metric of BUILTIN_RISK_METRICS) {
+            this.registerMetric(metric);
+        }
+        for (const metric of BUILTIN_BENEFIT_METRICS) {
+            this.registerMetric(metric);
+        }
+    }
+}
+export function getMetricRegistry() {
+    return MetricRegistry.Instance();
+}
+export const BUILTIN_METRICS_COUNT = BUILTIN_RISK_METRICS.length + BUILTIN_BENEFIT_METRICS.length;

package/dist/extensions/mode-evaluator.d.ts

@@ -0,0 +1,15 @@
+import type { IndustryMode, ModeEvaluation, ModeMigrationEvaluation, ProjectContext } from "./types.js";
+import type { CapabilityRegistry } from "./capability-manifest.js";
+import { MetricRegistry } from "./metric-registry.js";
+import { ConstraintRegistry } from "./constraint-registry.js";
+export declare class ModeEvaluator {
+    private capabilityRegistry;
+    private metricRegistry;
+    private constraintRegistry;
+    constructor(capabilityRegistry: CapabilityRegistry, metricRegistry?: MetricRegistry, constraintRegistry?: ConstraintRegistry);
+    evaluateMode(mode: IndustryMode, intent: string, context: ProjectContext): ModeEvaluation;
+    evaluateMigration(source: IndustryMode, target: IndustryMode): ModeMigrationEvaluation;
+    private isCustomMode;
+    private checkCapabilityConflicts;
+    private generateRecommendations;
+}

package/dist/extensions/mode-evaluator.js

@@ -0,0 +1,170 @@
+import { MetricRegistry } from "./metric-registry.js";
+import { ConstraintRegistry } from "./constraint-registry.js";
+export class ModeEvaluator {
+    capabilityRegistry;
+    metricRegistry;
+    constraintRegistry;
+    constructor(capabilityRegistry, metricRegistry, constraintRegistry) {
+        this.capabilityRegistry = capabilityRegistry;
+        this.metricRegistry = metricRegistry ?? MetricRegistry.Instance();
+        this.constraintRegistry = constraintRegistry ?? ConstraintRegistry.Instance();
+    }
+    evaluateMode(mode, intent, context) {
+        const capability_conflicts = this.checkCapabilityConflicts(mode);
+        const customConstraints = this.isCustomMode(mode) ? mode.custom_constraints : undefined;
+        const constraintViolations = this.constraintRegistry.checkConstraints(mode, this.capabilityRegistry, customConstraints);
+        const violated_constraints = constraintViolations
+            .filter(v => v.severity === "hard")
+            .map(v => `${v.display_name}: ${v.violation}`);
+        const unmet_conditions = constraintViolations
+            .filter(v => v.severity === "soft")
+            .map(v => `${v.display_name}: ${v.violation}`);
+        const customMetrics = this.isCustomMode(mode) ? mode.custom_metrics : undefined;
+        const metricEval = this.metricRegistry.evaluateMode(mode, this.capabilityRegistry, customMetrics);
+        const risk_score = metricEval.risk_score;
+        const benefit_score = metricEval.benefit_score;
+        const risk_benefit_ratio = benefit_score / Math.max(risk_score, 1);
+        const applicable = capability_conflicts.length === 0 &&
+            violated_constraints.length === 0;
+        const recommendations = this.generateRecommendations(mode, risk_score, benefit_score, capability_conflicts, violated_constraints, unmet_conditions);
+        return {
+            applicable,
+            risk_score,
+            benefit_score,
+            risk_benefit_ratio,
+            capability_conflicts,
+            violated_constraints,
+            unmet_conditions,
+            recommendations,
+        };
+    }
+    evaluateMigration(source, target) {
+        const sourceCaps = new Set(source.capabilities_used);
+        const targetCaps = new Set(target.capabilities_used);
+        const added_capabilities = [];
+        const removed_capabilities = [];
+        const conflicting_capabilities = [];
+        for (const cap of targetCaps) {
+            if (!sourceCaps.has(cap))
+                added_capabilities.push(cap);
+        }
+        for (const cap of sourceCaps) {
+            if (!targetCaps.has(cap))
+                removed_capabilities.push(cap);
+        }
+        const targetConflicts = this.checkCapabilityConflicts(target);
+        conflicting_capabilities.push(...targetConflicts);
+        const sourceMetric = this.metricRegistry.evaluateMode(source, this.capabilityRegistry);
+        const targetMetric = this.metricRegistry.evaluateMode(target, this.capabilityRegistry);
+        const source_risk_score = sourceMetric.risk_score;
+        const target_risk_score = targetMetric.risk_score;
+        const source_benefit_score = sourceMetric.benefit_score;
+        const target_benefit_score = targetMetric.benefit_score;
+        const risk_delta = target_risk_score - source_risk_score;
+        const benefit_delta = target_benefit_score - source_benefit_score;
+        let feasibility_score = 50;
+        feasibility_score += benefit_delta * 0.5;
+        feasibility_score -= risk_delta * 0.3;
+        feasibility_score -= conflicting_capabilities.length * 10;
+        feasibility_score -= added_capabilities.length * 2;
+        feasibility_score = Math.max(0, Math.min(100, Math.round(feasibility_score)));
+        const recommendations = [];
+        if (benefit_delta > 0) {
+            recommendations.push(`Benefit increased by ${benefit_delta.toFixed(1)} points, migration has positive value`);
+        }
+        else if (benefit_delta < 0) {
+            recommendations.push(`Benefit decreased by ${Math.abs(benefit_delta).toFixed(1)} points, need to evaluate migration necessity`);
+        }
+        if (risk_delta > 10) {
+            recommendations.push(`Risk increased by ${risk_delta.toFixed(1)} points, recommend strengthening risk control measures`);
+        }
+        else if (risk_delta < -10) {
+            recommendations.push(`Risk decreased by ${Math.abs(risk_delta).toFixed(1)} points, migration helps risk management`);
+        }
+        if (added_capabilities.length > 0) {
+            recommendations.push(`Added ${added_capabilities.length} capabilities, need extra configuration: ${added_capabilities.slice(0, 3).join(", ")}`);
+        }
+        if (removed_capabilities.length > 0) {
+            recommendations.push(`Removed ${removed_capabilities.length} capabilities, related features will be unavailable`);
+        }
+        if (conflicting_capabilities.length > 0) {
+            recommendations.push(`Detected ${conflicting_capabilities.length} capability conflicts, must be resolved before migration`);
+        }
+        if (feasibility_score >= 70) {
+            recommendations.push("Migration feasibility is high, recommend executing");
+        }
+        else if (feasibility_score >= 40) {
+            recommendations.push("Migration feasibility is medium, need careful evaluation");
+        }
+        else {
+            recommendations.push("Migration feasibility is low, recommend keeping the current mode or finding an alternative");
+        }
+        return {
+            feasibility_score,
+            source_risk_score,
+            target_risk_score,
+            source_benefit_score,
+            target_benefit_score,
+            risk_delta,
+            benefit_delta,
+            added_capabilities,
+            removed_capabilities,
+            conflicting_capabilities,
+            recommendations,
+        };
+    }
+    isCustomMode(mode) {
+        return mode.owner !== undefined &&
+            mode.source === "custom";
+    }
+    checkCapabilityConflicts(mode) {
+        const conflicts = [];
+        const caps = mode.capabilities_used;
+        for (const capId of caps) {
+            const card = this.capabilityRegistry.getCard(capId);
+            if (!card?.constraints?.conflicts_with)
+                continue;
+            for (const conflictId of card.constraints.conflicts_with) {
+                if (caps.includes(conflictId)) {
+                    conflicts.push(`${capId} conflicts with ${conflictId}`);
+                }
+            }
+            if (card.constraints.must_pair_with) {
+                for (const requiredId of card.constraints.must_pair_with) {
+                    if (!caps.includes(requiredId)) {
+                        conflicts.push(`${capId} requires ${requiredId} (must_pair_with not satisfied)`);
+                    }
+                }
+            }
+        }
+        return conflicts;
+    }
+    generateRecommendations(mode, risk_score, benefit_score, capability_conflicts, violated_constraints, unmet_conditions) {
+        const recs = [];
+        if (capability_conflicts.length > 0) {
+            recs.push(`Detected ${capability_conflicts.length} capability conflicts, must be resolved before applying the mode`);
+        }
+        if (violated_constraints.length > 0) {
+            recs.push(`Detected ${violated_constraints.length} hard constraint violations, need to supplement missing capabilities or adjust mode configuration`);
+        }
+        if (unmet_conditions.length > 0) {
+            recs.push(`Detected ${unmet_conditions.length} soft constraints not met, recommend adjusting to improve mode quality`);
+        }
+        const appetiteThresholds = {
+            conservative: { max_risk: 30, min_benefit: 50 },
+            balanced: { max_risk: 60, min_benefit: 60 },
+            aggressive: { max_risk: 100, min_benefit: 80 },
+        };
+        const threshold = appetiteThresholds[mode.risk_appetite];
+        if (risk_score > threshold.max_risk) {
+            recs.push(`Risk score ${risk_score} exceeds ${mode.risk_appetite} mode threshold ${threshold.max_risk}, recommend reducing risk or adjusting risk appetite`);
+        }
+        if (benefit_score < threshold.min_benefit) {
+            recs.push(`Benefit score ${benefit_score} below ${mode.risk_appetite} mode threshold ${threshold.min_benefit}, recommend adding benefit capabilities or adjusting risk appetite`);
+        }
+        if (recs.length === 0) {
+            recs.push(`Mode evaluation passed: risk ${risk_score} / benefit ${benefit_score} / risk-benefit ratio ${(benefit_score / Math.max(risk_score, 1)).toFixed(2)}`);
+        }
+        return recs;
+    }
+}