@wowok/agent-mcp 2.5.3 → 2.5.5

package/dist/knowledge/reward-confirm.d.ts

@@ -81,6 +81,7 @@ export interface RewardJsonForConfirm {
     guard_expiration_time?: number | null;
     owner_receive?: unknown;
     um?: string | null;
+    guard_expected_progress_state?: string;
 }
 export interface RewardConfirmGateInput {
     reward_json: RewardJsonForConfirm;
@@ -97,6 +98,8 @@ export interface RewardConfirmGateInput {
     passport_submission_value_types?: Record<number, string>;
     passport_identifier_is_address?: Record<number, boolean>;
     guard_store_from_id_compatible?: Record<string, boolean>;
+    user_intent_phrases?: string[];
+    machine_has_wonder_node?: boolean;
     skip_user_confirmation?: boolean;
     skip_environment_check?: boolean;
 }

package/dist/knowledge/reward-confirm.js

@@ -11,6 +11,7 @@ export const REWARD_OPERATION_CHECKLIST = [
     { id: "C-R-08", description: "claim: Passport is provided (SDK W_ERROR if missing)", passed: false, message: "" },
     { id: "C-R-09", description: "owner_receive (156): user double-confirms blast radius", passed: false, message: "" },
     { id: "C-R-10", description: "guard_expiration_time_add (155): new time > current clock", passed: false, message: "" },
+    { id: "C-R-11", description: "guard_add: Guard's progress.current expected value matches business intent (praise→wonder, completion→completed)", passed: false, message: "" },
 ];
 function runStaticChecklist(input) {
     const items = REWARD_OPERATION_CHECKLIST.map(c => ({ ...c }));
@@ -133,6 +134,22 @@ function runStaticChecklist(input) {
     else {
         cr10.passed = true;
     }
+    const cr11 = items.find(i => i.id === "C-R-11");
+    if (data.guard_expected_progress_state && input.user_intent_phrases && input.user_intent_phrases.length > 0) {
+        const intentLower = input.user_intent_phrases.join(" ").toLowerCase();
+        const praiseKeywords = ["好评", "praise", "wonder", "thumbs_up", "positive review", "satisfaction reward", "好评奖励"];
+        const isPraiseIntent = praiseKeywords.some(kw => intentLower.includes(kw.toLowerCase()));
+        if (isPraiseIntent && input.machine_has_wonder_node !== false && data.guard_expected_progress_state !== "wonder") {
+            cr11.passed = false;
+            cr11.message = `intent=praise but Guard checks "${data.guard_expected_progress_state}" instead of "wonder" — R-R-6-01 violation`;
+        }
+        else {
+            cr11.passed = true;
+        }
+    }
+    else {
+        cr11.passed = true;
+    }
     return {
         all_passed: items.filter(i => i.id !== "C-R-09").every(i => i.passed),
         items,
@@ -162,6 +179,9 @@ function adaptRiskAssessment(input) {
         passport_submission_value_types: input.passport_submission_value_types,
         passport_identifier_is_address: input.passport_identifier_is_address,
         guard_store_from_id_compatible: input.guard_store_from_id_compatible,
+        user_intent_phrases: input.user_intent_phrases,
+        guard_expected_progress_state: input.reward_json.guard_expected_progress_state,
+        machine_has_wonder_node: input.machine_has_wonder_node,
     };
     return assessRewardRisks(ctx);
 }
@@ -201,6 +221,14 @@ export const REWARD_CONFIRMATION_QUESTIONS = [
         requires_explicit_yes: false,
         related_risk_ids: ["R-R-5-02"],
     },
+    {
+        id: "QRW7",
+        question: "⚠️ For guard_add with progress.current check: does the Guard's expected progress node match the business intent? " +
+            "If intent is '好评/praise', Guard must check 'wonder' (NOT 'completed'). " +
+            "Premature claim at wrong node drains reward pool — Guard is immutable after creation.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-R-6-01", "R-R-6-02"],
+    },
 ];
 function processUserConfirmation(input, assessment) {
     const questions = [...REWARD_CONFIRMATION_QUESTIONS];
@@ -217,6 +245,8 @@ function processUserConfirmation(input, assessment) {
             continue;
         if (q.id === "QRW6" && !data.coin_add)
             continue;
+        if (q.id === "QRW7" && (!data.guard_add || !data.guard_expected_progress_state))
+            continue;
         filtered.push(q);
     }
     if (input.skip_user_confirmation) {

package/dist/knowledge/reward-puzzle.d.ts

@@ -48,6 +48,7 @@ export interface RewardConstraintChecklist {
     F_R_06_recipient_amount_valid_pairing: boolean;
     F_R_07_coin_type_matches_reward_t: boolean;
     F_R_08_passport_required_for_claim: boolean;
+    F_R_09_progress_node_matches_intent: boolean;
 }
 export type RewardPuzzleDimension = "A" | "B" | "C" | "D" | "E" | "F";
 export interface RewardPuzzle {

package/dist/knowledge/reward-puzzle.js

@@ -29,6 +29,7 @@ export function initPuzzleFromIntent(intent) {
         F_R_06_recipient_amount_valid_pairing: false,
         F_R_07_coin_type_matches_reward_t: false,
         F_R_08_passport_required_for_claim: false,
+        F_R_09_progress_node_matches_intent: true,
     };
     return puzzle;
 }
@@ -177,6 +178,17 @@ export function validateConstraints(puzzle) {
             message: "claim requires Passport — SDK W_ERROR if missing",
         });
     }
+    if (puzzle.guard && puzzle.intent && puzzle.constraints) {
+        if (!puzzle.constraints.F_R_09_progress_node_matches_intent) {
+            violations.push({
+                constraint_id: "F-R-09",
+                severity: "HIGH",
+                message: "Guard's expected progress.current value does not match business intent — " +
+                    "praise reward (好评/wonder) must check 'wonder' node, not 'completed'. " +
+                    "Guard is immutable after creation; mismatch requires full rebuild.",
+            });
+        }
+    }
     return violations;
 }
 export function generateConfirmationText(puzzle) {

package/dist/knowledge/reward-risk.d.ts

@@ -1,6 +1,6 @@
 import { type RewardScene, type RewardAmountType } from "./reward-ledger.js";
 export type RewardRiskLevel = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
-export type RewardRiskCategory = "structural" | "semantic" | "permission" | "lifecycle" | "cross_object";
+export type RewardRiskCategory = "structural" | "semantic" | "permission" | "lifecycle" | "cross_object" | "business_semantic";
 export interface RewardRisk {
     id: string;
     level: RewardRiskLevel;
@@ -65,6 +65,9 @@ export interface RewardRiskCheckContext {
     passport_submission_value_types?: Record<number, string>;
     passport_identifier_is_address?: Record<number, boolean>;
     guard_store_from_id_compatible?: Record<string, boolean>;
+    user_intent_phrases?: string[];
+    guard_expected_progress_state?: string;
+    machine_has_wonder_node?: boolean;
 }
 export declare const REWARD_RISK_VERSION = "1.0.0";
 export declare function getAllRewardRiskRules(): RewardRiskRule[];

package/dist/knowledge/reward-risk.js

@@ -469,12 +469,94 @@ const R_R_5_03 = {
         return null;
     },
 };
+const R_R_6_01 = {
+    id: "R-R-6-01",
+    category: "business_semantic",
+    trigger: "intent mentions praise/好评 but Guard checks non-wonder progress node",
+    check: (ctx) => {
+        if (!ctx.user_intent_phrases || ctx.user_intent_phrases.length === 0)
+            return null;
+        if (!ctx.guard_expected_progress_state)
+            return null;
+        const intentLower = ctx.user_intent_phrases.join(" ").toLowerCase();
+        const praiseKeywords = [
+            "好评", "praise", "wonder", "thumbs_up",
+            "positive review", "satisfaction reward", "好评奖励",
+        ];
+        const isPraiseIntent = praiseKeywords.some(kw => intentLower.includes(kw.toLowerCase()));
+        if (!isPraiseIntent)
+            return null;
+        if (ctx.machine_has_wonder_node === false)
+            return null;
+        const expected = ctx.guard_expected_progress_state;
+        if (expected !== "wonder") {
+            return {
+                id: "R-R-6-01",
+                level: "HIGH",
+                category: "business_semantic",
+                title: `Guard checks progress=="${expected}" but intent indicates praise reward (wonder node)`,
+                description: `User intent mentions praise/好评/wonder, which maps to the 'wonder' progress node ` +
+                    `(customer gives positive review AFTER service completion). But the Guard's table bakes ` +
+                    `expected state="${expected}", allowing reward claim at the wrong lifecycle stage. ` +
+                    `This violates the business semantics: "好评奖励" should only be claimable AFTER the ` +
+                    `customer advances to the 'wonder' node, not before. ` +
+                    `Guard is immutable — fixing this requires creating a new Guard + Reward pair.`,
+                affected_stakeholders: ["owner", "service_provider", "claimer"],
+                scenario: "Designer builds Guard checking 'completed' instead of 'wonder' for a praise reward",
+                mitigation: "Set the Guard table's expected progress state to 'wonder' (the positive-review node). " +
+                    "The correct pattern: ordered → in_service → completed → wonder (praise) triggers reward claim. " +
+                    "Reference: reward-templates.ts wonder_praise template.",
+                evidence: `intent="${intentLower}", expected_state="${expected}", expected_wonder=true`,
+                auto_fixable: false,
+            };
+        }
+        return null;
+    },
+};
+const R_R_6_02 = {
+    id: "R-R-6-02",
+    category: "business_semantic",
+    trigger: "Guard checks wonder node but intent does not mention praise",
+    check: (ctx) => {
+        if (!ctx.user_intent_phrases || ctx.user_intent_phrases.length === 0)
+            return null;
+        if (!ctx.guard_expected_progress_state)
+            return null;
+        if (ctx.guard_expected_progress_state !== "wonder")
+            return null;
+        const intentLower = ctx.user_intent_phrases.join(" ").toLowerCase();
+        const praiseKeywords = [
+            "好评", "praise", "wonder", "thumbs_up",
+            "positive review", "satisfaction reward", "好评奖励",
+        ];
+        const isPraiseIntent = praiseKeywords.some(kw => intentLower.includes(kw.toLowerCase()));
+        if (isPraiseIntent)
+            return null;
+        return {
+            id: "R-R-6-02",
+            level: "MEDIUM",
+            category: "business_semantic",
+            title: "Guard checks wonder node but intent does not mention praise",
+            description: `Guard's expected progress state is "wonder" (positive-review node), but the user intent ` +
+                `does not mention any praise/好评 keyword. This may be a copy-paste from a wonder_praise ` +
+                `template without adjusting the Guard for the actual business semantics. If this is a ` +
+                `general feedback reward (wonder_feedback), this is fine. Otherwise, verify the node choice.`,
+            affected_stakeholders: ["owner"],
+            scenario: "Designer copies wonder_praise template but actually wants a completion-based reward",
+            mitigation: "Verify: if intent is praise reward, add '好评/praise' to description. " +
+                "If intent is completion-based reward, change Guard to check 'completed' node.",
+            evidence: `expected_state="wonder", intent="${intentLower}" (no praise keyword)`,
+            auto_fixable: false,
+        };
+    },
+};
 const ALL_RULES = [
     R_R_1_01, R_R_1_02, R_R_1_03,
     R_R_2_01, R_R_2_02, R_R_2_03, R_R_2_04,
     R_R_3_01, R_R_3_02, R_R_3_03,
     R_R_4_01, R_R_4_02, R_R_4_03, R_R_4_04,
     R_R_5_01, R_R_5_02, R_R_5_03,
+    R_R_6_01, R_R_6_02,
 ];
 export const REWARD_RISK_VERSION = "1.0.0";
 export function getAllRewardRiskRules() {
@@ -529,13 +611,13 @@ export const REWARD_STAKEHOLDERS = [
 export function getRewardRiskRulesByStakeholder(stakeholder) {
     return ALL_RULES.filter(rule => {
         if (stakeholder === "owner") {
-            return ["structural", "permission", "lifecycle"].includes(rule.category);
+            return ["structural", "permission", "lifecycle", "business_semantic"].includes(rule.category);
         }
         if (stakeholder === "claimer") {
-            return rule.id.startsWith("R-R-4-0") || rule.id === "R-R-5-01" || rule.id === "R-R-1-02";
+            return rule.id.startsWith("R-R-4-0") || rule.id === "R-R-5-01" || rule.id === "R-R-1-02" || rule.id === "R-R-6-01";
         }
         if (stakeholder === "service_provider") {
-            return rule.id === "R-R-4-02" || rule.id === "R-R-3-01" || rule.id === "R-R-3-02";
+            return rule.id === "R-R-4-02" || rule.id === "R-R-3-01" || rule.id === "R-R-3-02" || rule.id === "R-R-6-01";
         }
         if (stakeholder === "system") {
             return rule.category === "cross_object";

package/dist/knowledge/reward-templates.d.ts

@@ -1,4 +1,4 @@
-export type RewardTemplateType = "first_order" | "referral" | "loyalty" | "flash_sale" | "bulk_discount" | "milestone" | "cashback";
+export type RewardTemplateType = "first_order" | "referral" | "loyalty" | "flash_sale" | "bulk_discount" | "milestone" | "cashback" | "wonder_praise" | "wonder_feedback";
 export interface RewardTemplate {
     type: RewardTemplateType;
     name: string;

package/dist/knowledge/reward-templates.js

@@ -92,6 +92,68 @@ export const REWARD_TEMPLATES = [
         example: "Service reaches the 100-order milestone; the first 50 customers each receive 5 WOW extra reward.",
         relevantGuardOps: ["query", "repository_read"],
     },
+    {
+        type: "wonder_praise",
+        name: "Wonder-node praise reward (post-completion positive feedback)",
+        description: "Rewards customers who advance their order Progress to the 'wonder' node after normal completion — " +
+            "a user-driven positive-feedback mechanism. The machine design pattern is: " +
+            "place_order → booked → in_progress → completed → (wonder | no_wonder). " +
+            "After the order reaches 'completed' (terminal business state), the OrderHolder " +
+            "(namedOperator='') can advance Progress to 'wonder' (positive review) or 'no_wonder' " +
+            "(negative review). The Reward's claim_guard verifies Progress.current == 'wonder' " +
+            "AND order.service == this Service, so only satisfied customers can claim. " +
+            "This creates an on-chain reputation signal that benefits both the merchant " +
+            "(public proof of quality) and the customer (monetary reward for honest feedback).",
+        guardCondition: "Guard verifies: (1) Progress.current == 'wonder' (customer advanced to praise node), " +
+            "(2) Progress.task == order_address AND order.service == this Service, " +
+            "(3) Progress.machine == service.machine (snapshot match), " +
+            "(4) claimer is the order holder (order.holder == signer). " +
+            "Recommended Guard ops: query Progress object, query Order object, " +
+            "verify Progress.current field equals 'wonder'.",
+        amountRange: { min: "0.1WOW", max: "20WOW" },
+        allocationStrategy: "fixed",
+        parameters: [
+            { name: "amount", type: "string", description: "Reward amount per praise (e.g., '1WOW')", required: true },
+            { name: "budget", type: "string", description: "Total budget (e.g., '500WOW')", required: true },
+            { name: "expiration_time", type: "number", description: "Claim expiration timestamp (ms); 0 = no expiration", required: false },
+            { name: "max_claims_per_user", type: "number", description: "Max claims per user (default 1, prevents duplicate praise rewards)", required: false },
+        ],
+        example: "A photography service machine: place_order → booked → in_progress → completed → wonder. " +
+            "After delivery, the customer advances Progress to 'wonder' if satisfied. " +
+            "The Reward's Guard verifies Progress.current == 'wonder', and the customer claims 1 WOW. " +
+            "Merchant benefits from on-chain proof of customer satisfaction.",
+        relevantGuardOps: ["query", "progress_node_check"],
+    },
+    {
+        type: "wonder_feedback",
+        name: "Wonder-node feedback collection (covers wonder & no_wonder)",
+        description: "A feedback-collection Reward that pays a small amount for EITHER positive (wonder) OR " +
+            "negative (no_wonder) feedback, encouraging customers to leave honest reviews. " +
+            "The machine design pattern is the same as wonder_praise: " +
+            "place_order → booked → in_progress → completed → (wonder | no_wonder). " +
+            "The Reward's claim_guard verifies Progress.current ∈ {'wonder', 'no_wonder'} — both nodes " +
+            "trigger the reward. This is useful for merchants who want to gather feedback signal " +
+            "regardless of sentiment, e.g., for product improvement or public reputation metrics. " +
+            "Pair with a Repository that records the feedback node for historical analysis.",
+        guardCondition: "Guard verifies: (1) Progress.current ∈ {'wonder', 'no_wonder'}, " +
+            "(2) Progress.task == order_address AND order.service == this Service, " +
+            "(3) claimer is the order holder. " +
+            "The Guard should query the Progress object and check that current node is one of the " +
+            "two feedback nodes. Optional: write the feedback node to a Repository for analytics.",
+        amountRange: { min: "0.05WOW", max: "5WOW" },
+        allocationStrategy: "fixed",
+        parameters: [
+            { name: "amount", type: "string", description: "Reward amount per feedback (e.g., '0.5WOW')", required: true },
+            { name: "budget", type: "string", description: "Total budget (e.g., '200WOW')", required: true },
+            { name: "feedback_nodes", type: "string", description: "Comma-separated list of feedback node names (default: 'wonder,no_wonder')", required: false },
+            { name: "expiration_time", type: "number", description: "Claim expiration timestamp (ms); 0 = no expiration", required: false },
+        ],
+        example: "A freelance design service: place_order → ... → completed → (wonder | no_wonder). " +
+            "Customer advances to 'wonder' (liked the work) or 'no_wonder' (didn't like it). " +
+            "Both trigger a 0.5 WOW feedback reward. Merchant tracks the wonder/no_wonder ratio " +
+            "in a Repository to identify quality issues and improve service.",
+        relevantGuardOps: ["query", "progress_node_check", "repository_write"],
+    },
 ];
 const TEMPLATE_INDEX = new Map(REWARD_TEMPLATES.map((t) => [t.type, t]));
 export function getRewardTemplate(type) {
@@ -102,22 +164,32 @@ export function listRewardTemplates() {
 }
 export function suggestRewardTemplate(intent) {
     const lower = intent.toLowerCase();
+    if (lower.includes("wonder") || lower.includes("praise") || lower.includes("thumbs_up")
+        || lower.includes("好评") || lower.includes("positive review")
+        || lower.includes("satisfaction reward")) {
+        return getRewardTemplate("wonder_praise");
+    }
+    if (lower.includes("feedback") || lower.includes("review collection")
+        || lower.includes("no_wonder") || lower.includes("thumbs_down")
+        || lower.includes("差评") || lower.includes("both sentiment")) {
+        return getRewardTemplate("wonder_feedback");
+    }
     if (lower.includes("first order") || lower.includes("new") || lower.includes("first")) {
         return getRewardTemplate("first_order");
     }
-    if (lower.includes("referral") || lower.includes("viral") || lower.includes("referral")) {
+    if (lower.includes("referral") || lower.includes("viral")) {
         return getRewardTemplate("referral");
     }
-    if (lower.includes("repeat") || lower.includes("loyalty") || lower.includes("loyalty")) {
+    if (lower.includes("repeat") || lower.includes("loyalty")) {
         return getRewardTemplate("loyalty");
     }
-    if (lower.includes("limited-time") || lower.includes("flash") || lower.includes("flash")) {
+    if (lower.includes("limited-time") || lower.includes("flash")) {
         return getRewardTemplate("flash_sale");
     }
-    if (lower.includes("cashback") || lower.includes("cashback")) {
+    if (lower.includes("cashback")) {
         return getRewardTemplate("cashback");
     }
-    if (lower.includes("milestone") || lower.includes("milestone")) {
+    if (lower.includes("milestone")) {
         return getRewardTemplate("milestone");
     }
     return undefined;

package/dist/knowledge/tools-reference.js

@@ -105,11 +105,12 @@ export const TOOLS_REFERENCE = [
     },
     {
         name: "project_operation",
-        summary: "Project namespace + object dependency graph (DAG) + GLM5 C1-C4 composite actions.",
-        actions: ["list_projects", "list_objects", "shareable", "dependencies", "referenced_by", "pre_publish_check", "cross_project_refs", "graph_stats", "save_graph", "load_graph", "analyze_intent", "aggregate_risks", "generate_deployment_doc", "trace_substeps"],
+        summary: "Project entity management (SQLite) + 3-pathway graph construction + dual rule-based/LLM-assisted evaluation engine.",
+        actions: ["list_projects", "create_project", "create_project_from_onchain", "update_project", "get_project_detail", "add_object", "remove_object", "create_version", "build_graph", "get_graph", "evaluate_project", "save_evaluation", "compare_projects", "refresh_objects", "get_object_diff", "assemble_context"],
         notes: [
-            "GLM5: C1-C4 actions drive the 5-stage project-based deployment flow.",
-            "Non-blocking: only CRITICAL risks block; HIGH/MEDIUM/LOW are advisory.",
+            "GLM6: Projects are first-class entities with SQLite persistence, rigid project-object relationships.",
+            "Evaluation: risk/trust/completeness are rule-based (computed locally). value/worth_buying require LLM assistance (returns a prompt).",
+            "Graph: 3 pathways — internal references (configurable depth), Registrar inbound (O(1)), potential relationships.",
         ],
     },
     {

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

@@ -1,6 +1,9 @@
 export interface ServiceTrustMetrics {
     arbitrationScore?: number;
     arbitrationCases?: number;
+    arbitrationVotingGuardCount?: number;
+    arbitrationFeeBalance?: bigint;
+    arbitrationPaused?: boolean;
     reviewStats?: {
         likes: number;
         dislikes: number;
@@ -11,6 +14,7 @@ export interface ServiceTrustMetrics {
     completedRate?: number;
     avgCompletionTime?: number;
     compensationFundBalance?: bigint;
+    typicalOrderAmount?: bigint;
     hasPublishedEvents?: boolean;
     hasMachineBound?: boolean;
     hasBuyGuard?: boolean;

package/dist/knowledge/trust-metrics.js

@@ -38,16 +38,51 @@ export function computeServiceTrustScore(metrics) {
 }
 function computeArbitrationDimension(metrics) {
     const maxScore = 30;
-    if (metrics.arbitrationScore === undefined) {
-        return { name: "arbitration", score: maxScore * 0.5, maxScore, description: "Arbitration trust score (no data, default moderate)", humanReadable: "Arbitration record: no data" };
+    if (metrics.arbitrationScore === undefined && metrics.arbitrationVotingGuardCount === undefined) {
+        return {
+            name: "arbitration",
+            score: maxScore * 0.25,
+            maxScore,
+            description: "Arbitration trust score (no data; default low because arbitration is critical)",
+            humanReadable: "Arbitration: no data (default low — critical missing)",
+        };
     }
-    const score = Math.round((metrics.arbitrationScore / 100) * maxScore);
+    let score = 0;
+    const parts = [];
+    if (metrics.arbitrationScore !== undefined) {
+        const baseScore = Math.round((metrics.arbitrationScore / 100) * 10);
+        score += baseScore;
+        parts.push(`score ${metrics.arbitrationScore}/100`);
+    }
+    else {
+        score += 3;
+    }
+    if (metrics.arbitrationVotingGuardCount !== undefined && metrics.arbitrationVotingGuardCount > 0) {
+        score += 5;
+        parts.push(`${metrics.arbitrationVotingGuardCount} voting_guard(s)`);
+    }
+    if (metrics.arbitrationFeeBalance !== undefined && metrics.arbitrationFeeBalance > 0n) {
+        score += 5;
+        parts.push("fee funded");
+    }
+    if (metrics.arbitrationPaused === false) {
+        score += 5;
+        parts.push("active");
+    }
+    else if (metrics.arbitrationPaused === true) {
+        parts.push("paused");
+    }
+    if (metrics.arbitrationCases !== undefined && metrics.arbitrationCases > 0) {
+        score += 5;
+        parts.push(`${metrics.arbitrationCases} case(s)`);
+    }
+    score = Math.min(maxScore, score);
     return {
         name: "arbitration",
         score,
         maxScore,
-        description: `Arbitration trust score ${metrics.arbitrationScore}/100`,
-        humanReadable: `Arbitration trust: ${metrics.arbitrationScore}/100${metrics.arbitrationCases !== undefined ? ` (${metrics.arbitrationCases} cases)` : ""}`,
+        description: `Arbitration config: ${parts.join(", ")}`,
+        humanReadable: `Arbitration: ${parts.join(", ")}`,
     };
 }
 function computeReviewDimension(metrics) {
@@ -94,6 +129,31 @@ function computeFundDimension(metrics) {
     if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
         return { name: "fund_safety", score: 0, maxScore, description: "No compensation fund", humanReadable: "Compensation fund: none" };
     }
+    const fund = metrics.compensationFundBalance;
+    if (metrics.typicalOrderAmount !== undefined && metrics.typicalOrderAmount > 0n) {
+        const ratio = Number((fund * 100n) / metrics.typicalOrderAmount) / 100;
+        let score;
+        let humanReadable;
+        if (ratio >= 10) {
+            score = maxScore;
+            humanReadable = `Compensation fund: ${ratio.toFixed(1)}x order amount (excellent)`;
+        }
+        else if (ratio >= 1) {
+            score = 10 + Math.round((ratio - 1) / 9 * 5);
+            humanReadable = `Compensation fund: ${ratio.toFixed(1)}x order amount (covers ≥1 payout)`;
+        }
+        else {
+            score = Math.round(ratio * 10);
+            humanReadable = `Compensation fund: ${ratio.toFixed(1)}x order amount (insufficient)`;
+        }
+        return {
+            name: "fund_safety",
+            score: Math.min(maxScore, score),
+            maxScore,
+            description: `Fund ${fund.toString()} / typical order ${metrics.typicalOrderAmount.toString()} = ${ratio.toFixed(2)}x`,
+            humanReadable,
+        };
+    }
     const threshold = 1000000000000n;
     const ratio = Number(metrics.compensationFundBalance * 100n / threshold) / 100;
     const score = Math.min(maxScore, Math.round(ratio * maxScore));
@@ -101,8 +161,8 @@ function computeFundDimension(metrics) {
         name: "fund_safety",
         score,
         maxScore,
-        description: `Compensation fund ${metrics.compensationFundBalance} smallest unit`,
-        humanReadable: `Compensation fund: sufficient`,
+        description: `Compensation fund ${metrics.compensationFundBalance} smallest unit (absolute threshold fallback)`,
+        humanReadable: `Compensation fund: ${ratio.toFixed(2)}x absolute threshold`,
     };
 }
 function computeTransparencyDimension(metrics) {

package/dist/project/evaluation.d.ts

@@ -0,0 +1,53 @@
+import type { Project, ProjectObject, GraphEdge, ObjectCacheEntry, EvaluationType } from "@wowok/wowok";
+import type { ReputationData } from "./graph-builder.js";
+export interface CriterionScore {
+    name: string;
+    score: number;
+    weight: number;
+    rationale: string;
+}
+export interface EvaluationFinding {
+    criterion: string;
+    severity: "critical" | "warning" | "info";
+    message: string;
+    deduction: number;
+}
+export interface EvaluationResult {
+    evaluationType: EvaluationType;
+    score: number;
+    summary: string;
+    criterionScores: CriterionScore[];
+    findings: EvaluationFinding[];
+    strengths: string[];
+    needsLlm: boolean;
+    llmPrompt?: string;
+    evaluatedAt: number;
+}
+export interface EvaluationInput {
+    project: Project;
+    objects: ProjectObject[];
+    edges: GraphEdge[];
+    objectCache: Map<string, ObjectCacheEntry>;
+    reputation?: Map<string, ReputationData>;
+}
+export declare function runEvaluation(input: EvaluationInput, evaluationType: EvaluationType, llmPrompt?: string): EvaluationResult;
+export interface ProjectComparisonEntry {
+    projectId: string;
+    projectName: string;
+    score: number | null;
+    summary: string | null;
+    evaluatedAt: number | null;
+}
+export interface ProjectComparison {
+    evaluationType: EvaluationType;
+    entries: ProjectComparisonEntry[];
+    ranking: ProjectComparisonEntry[];
+    bestProjectId: string | null;
+}
+export declare function compareProjects(entries: Array<{
+    projectId: string;
+    projectName: string;
+    score: number | null;
+    summary: string | null;
+    evaluatedAt: number | null;
+}>, evaluationType: EvaluationType): ProjectComparison;