@wowok/agent-mcp 2.5.3 → 2.5.5

package/README.md

@@ -25,40 +25,47 @@ Docs: [https://github.com/wowok-ai/docs/](https://github.com/wowok-ai/docs/)
 }
 ```
 
-### 2. Use WoWok Skills (Recommended)
+### 2. Install WoWok Skills (Recommended)
 
-**Skills significantly reduce the learning curve and usage difficulty of the MCP Server.**
+**Skills significantly reduce the learning curve and usage difficulty of the MCP Server.** They provide structured guidance for AI assistants on complex system building, tool usage, and safety protocols.
 
 ```bash
+# Personal (global) — available in all sessions:
 npm install -g @wowok/skills
+
+# Project (team sharing) — commit to git for collaboration:
+cd your-project
+wowok-skills init          # Claude Code (default)
+wowok-skills init --target agents    # Trae IDE
+wowok-skills init --target all       # All 6 supported clients
 ```
 
-Skills provide structured guidance for AI assistants:
+**Supported clients:** Claude Code, OpenAI Codex, Trae IDE, CodeBuddy, Cursor, GitHub Copilot.
+
+#### Available Skills
+
+**Always loaded** (3 skills — foundational layer):
 
-- **Complex system building** — Dependency chains, build order, step-by-step patterns
-- **Tool usage failures** — Correct parameter formats, tool selection, error recovery
-- **Safety & authorization** — User confirmation for important operations
+| Skill | Purpose |
+|-------|---------|
+| `wowok-tools` | MCP tool reference — 17 sub-tools, schema-gated execution, constraints |
+| `wowok-safety` | Safety protocol — dry-run → confirm → execute, immutability rules |
+| `wowok-output` | Output processing — address resolution, name mapping, data visualization |
 
-#### Available Skills (Organized by Role)
+**On-demand** (11 skills — loaded by context):
 
 | Skill | Role | Purpose |
 |-------|------|---------|
-| `wowok-order` | 👤 Customer | Order lifecycle — place orders, track progress, submit disputes, claim compensation |
-| `wowok-provider` | 🏪 Provider | Service provider guide — create Service, design Machine, configure Allocators |
-| `wowok-machine` | 🏪 Provider | Workflow design — state machines, node definitions, progress tracking |
-| `wowok-arbitrator` | ⚖️ Arbitrator | Arbitration service — dispute resolution, voting organization, fee management |
-| `wowok-guard` | 🛠️ Shared | Guard design mastery — programmable trust rules, multi-signature authorization |
-| `wowok-messenger` | 🛠️ Shared | Encrypted messaging — E2E communication, WTS evidence, conversation management |
-| `wowok-output` | 🛠️ Shared | Output processing — post-process responses for human-readable presentation |
-| `wowok-tools` | 🛠️ Shared | MCP tool usage mastery — 13+ tools, parameter formats, schema references |
-| `wowok-safety` | 🛠️ Shared | Safety protocol — dry-run validation, user confirmation checkpoints |
-
-#### Role-Based Skill Selection
-
-- **Use `wowok-order`** when user acts as a customer/buyer placing orders
-- **Use `wowok-provider`** + `wowok-machine` when user is a merchant/service provider
-- **Use `wowok-arbitrator`** when user operates dispute resolution services
-- **Use `wowok-tools`** + `wowok-safety`** + `wowok-output` (always loaded) for all roles
-- **Use `wowok-guard`** when designing complex validation rules
-
-> **Note:** For detailed installation instructions for different AI clients (Claude Code, OpenAI Codex, Trae IDE, Cursor, etc.), see the [WoWok Skills](https://github.com/wowok-ai/skills) repository.
+| `wowok-provider` | 🏪 Provider | Service provider guide — create Service, Machine, Allocators, order fulfillment |
+| `wowok-machine` | 🏪 Provider | Workflow design — state machines, node/pair/forward graph, publish lifecycle |
+| `wowok-order` | 👤 Customer | Order lifecycle — due diligence, consensus, order creation, progress, arbitration |
+| `wowok-arbitrator` | ⚖️ Arbitrator | Arbitration service — dispute resolution, weighted voting, fee management |
+| `wowok-guard` | 🛠️ Shared | Guard design — programmable trust rules, 4 data sources, 33 constraints |
+| `wowok-messenger` | 🛠️ Shared | Encrypted messaging — E2E communication, WTS evidence, anti-spam |
+| `wowok-onboard` | 🆕 New User | First-touch onboarding — 10-round dialogue from zero to first published Service |
+| `wowok-scenario` | 🛠️ Shared | Industry mode templates — freelance, rental, education, travel presets |
+| `wowok-planner` | 🛠️ Shared | Planning — converts natural language intent into Object Dependency Graph (ODG) |
+| `wowok-auditor` | 🛠️ Shared | Pre-publish audit — Guard completeness, Machine soundness, 32 audit checks |
+| `wowok-distill` | 🏪 Provider | Distillation review — review AI-generated improvement proposals |
+
+> **Tip:** `wowok-tools` + `wowok-safety` + `wowok-output` are always loaded and serve all roles. Add role-specific skills (`wowok-provider`, `wowok-order`, `wowok-arbitrator`) as needed.

package/dist/customer/index.d.ts

@@ -1,5 +1,5 @@
-export { CUSTOMER_INTELLIGENCE_VERSION, RISK_LEVELS, RISK_DIMENSION_MAX, type PuzzleDepth, type ServiceBasics, type WorkflowAnalysis, type FundSafety, type TrustSignals, type MerchantBehavior, type MarketContext, type InfoPuzzle, type RiskDimensionName, type RiskCheck, type RiskDimensionScore, type RiskLevel, type RiskScore, type UserPreferences, type ReminderPriority, type Reminder, type GameScenario, type GameStrategy, type CustomerAdvice, } from "./types.js";
-export { assembleServiceBasics, assembleWorkflowAnalysis, assembleFundSafety, assembleTrustSignals, assembleMerchantBehavior, assembleMarketContext, assembleInfoPuzzle, type ServiceRawData, type MachineNodeRaw, type ReviewRaw, type EventRaw, type PuzzleRawData, } from "./info-puzzle.js";
+export { CUSTOMER_INTELLIGENCE_VERSION, RISK_LEVELS, RISK_DIMENSION_MAX, type PuzzleDepth, type ServiceBasics, type WorkflowAnalysis, type FundSafety, type TrustSignals, type MerchantBehavior, type MarketContext, type InfoPuzzle, type RiskDimensionName, type RiskCheck, type RiskDimensionScore, type RiskLevel, type RiskScore, type UserPreferences, type ReminderPriority, type Reminder, type GameScenario, type GameStrategy, type CustomerAdvice, type UserMetricEvaluatorType, type UserMetric, type UserMetricsConfig, type UserMetricResult, type UserMetricsResult, type ServiceNestingEvaluation, } from "./types.js";
+export { assembleServiceBasics, assembleWorkflowAnalysis, assembleFundSafety, assembleTrustSignals, assembleMerchantBehavior, assembleMarketContext, assembleInfoPuzzle, assembleUserMetrics, evaluateServiceNesting, type ServiceRawData, type MachineNodeRaw, type ReviewRaw, type EventRaw, type PuzzleRawData, type ServiceNestingRawData, } from "./info-puzzle.js";
 export { riskLevelFromScore, riskLevelLabel, riskLevelEmoji, assessRisk, passesRiskThreshold, } from "./risk-assessment.js";
 export { getIndustryRiskChecks, getIndustryNeeds, checkIndustryNeeds, assessIndustryRisks, inferIndustry, type IndustryNeedTier, type IndustryNeed, type IndustryRiskCheck, type IndustryRiskResult, } from "./industry-risks.js";
 export { getDefaultPreferences, getIndustryTemplate, inferPreferences, matchServiceToPreferences, mergePreferences, validatePreferences, SUPPORTED_INDUSTRIES, type Industry, type IndustryTemplate, type OrderHistoryEntry, type PreferenceInference, type ServiceForMatching, type PreferenceMatchResult, } from "./user-preferences.js";

package/dist/customer/index.js

@@ -1,5 +1,5 @@
 export { CUSTOMER_INTELLIGENCE_VERSION, RISK_LEVELS, RISK_DIMENSION_MAX, } from "./types.js";
-export { assembleServiceBasics, assembleWorkflowAnalysis, assembleFundSafety, assembleTrustSignals, assembleMerchantBehavior, assembleMarketContext, assembleInfoPuzzle, } from "./info-puzzle.js";
+export { assembleServiceBasics, assembleWorkflowAnalysis, assembleFundSafety, assembleTrustSignals, assembleMerchantBehavior, assembleMarketContext, assembleInfoPuzzle, assembleUserMetrics, evaluateServiceNesting, } from "./info-puzzle.js";
 export { riskLevelFromScore, riskLevelLabel, riskLevelEmoji, assessRisk, passesRiskThreshold, } from "./risk-assessment.js";
 export { getIndustryRiskChecks, getIndustryNeeds, checkIndustryNeeds, assessIndustryRisks, inferIndustry, } from "./industry-risks.js";
 export { getDefaultPreferences, getIndustryTemplate, inferPreferences, matchServiceToPreferences, mergePreferences, validatePreferences, SUPPORTED_INDUSTRIES, } from "./user-preferences.js";

package/dist/customer/info-puzzle.d.ts

@@ -1,4 +1,4 @@
-import type { InfoPuzzle, ServiceBasics, WorkflowAnalysis, FundSafety, TrustSignals, MerchantBehavior, MarketContext, PuzzleDepth } from "./types.js";
+import type { InfoPuzzle, ServiceBasics, WorkflowAnalysis, FundSafety, TrustSignals, MerchantBehavior, MarketContext, PuzzleDepth, UserMetricsConfig, UserMetricsResult, ServiceNestingEvaluation } from "./types.js";
 import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
 export interface ServiceRawData {
     name?: string;
@@ -60,7 +60,7 @@ export interface EventRaw {
     data?: Record<string, unknown>;
 }
 export declare function assembleServiceBasics(serviceId: string, raw: ServiceRawData, wipVerified?: boolean): ServiceBasics;
-export declare function assembleWorkflowAnalysis(nodes: MachineNodeRaw[], isPublished: boolean, isPaused: boolean): WorkflowAnalysis;
+export declare function assembleWorkflowAnalysis(nodes: MachineNodeRaw[], isPublished: boolean, isPaused: boolean, serviceRaw?: ServiceRawData): WorkflowAnalysis;
 export declare function assembleFundSafety(raw: ServiceRawData, orderAmount: bigint): FundSafety;
 export declare function assembleTrustSignals(service: ServiceRawData, reviews: ReviewRaw[], trustScore: {
     score: number;
@@ -97,6 +97,43 @@ export interface PuzzleRawData {
         has_dispute: boolean;
         is_repeat: boolean;
     }>;
+    user_metrics_config?: UserMetricsConfig;
+    user_metrics_context?: Record<string, unknown>;
+    service_nesting_raw?: ServiceNestingRawData;
+    service_nesting?: ServiceNestingEvaluation;
 }
 export declare function assembleInfoPuzzle(serviceId: string, raw: PuzzleRawData, depth?: PuzzleDepth): InfoPuzzle;
+export declare function assembleUserMetrics(config: UserMetricsConfig, context: Record<string, unknown>): UserMetricsResult;
+export interface ServiceNestingRawData {
+    service_id: string;
+    depth?: number;
+    maxDepth?: number;
+    machine?: {
+        object_id: string;
+        published: boolean;
+        paused: boolean;
+        has_dispute_anti_pattern?: boolean;
+        has_no_entry?: boolean;
+        has_no_terminal?: boolean;
+        structural_issue_count?: number;
+    };
+    arbitrations?: Array<{
+        object_id: string;
+        voting_guard_count: number;
+        fee_balance: bigint;
+        paused: boolean;
+    }>;
+    rewards?: Array<{
+        object_id: string;
+        balance: bigint;
+        guard_count: number;
+        expiration_time?: number;
+    }>;
+    repositories?: Array<{
+        object_id: string;
+        has_write_guard: boolean;
+        is_empty: boolean;
+    }>;
+}
+export declare function evaluateServiceNesting(raw: ServiceNestingRawData): ServiceNestingEvaluation | undefined;
 export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/customer/info-puzzle.js

@@ -22,17 +22,24 @@ export function assembleServiceBasics(serviceId, raw, wipVerified = false) {
         wip_verified: wipVerified,
     };
 }
-export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
+export function assembleWorkflowAnalysis(nodes, isPublished, isPaused, serviceRaw) {
     const riskSignals = [];
     const terminalNodes = [];
     const deadEndNodes = [];
     let userOperable = 0;
     let providerOnly = 0;
     let guardGated = 0;
-    let hasRefundPath = false;
-    let hasArbitrationPath = false;
     let hasMilestone = false;
+    let hasWonderNode = false;
+    let hasDisputeAntiPattern = false;
+    const antiPatternNodeRegex = /^(disputed|refunded|arb|arbitration|dispute|refund)$/i;
+    const wonderNodeRegex = /^(wonder|no_wonder|praise|complain|thumbs_up|thumbs_down|好评|差评)$/i;
     const totalForwards = nodes.reduce((sum, n) => sum + (n.forwards?.length ?? 0), 0);
+    for (const node of nodes) {
+        if (antiPatternNodeRegex.test(node.name.trim())) {
+            hasDisputeAntiPattern = true;
+        }
+    }
     for (const node of nodes) {
         const outForwards = node.forwards ?? [];
         if (outForwards.length === 0) {
@@ -55,15 +62,11 @@ export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
             else {
                 providerOnly++;
             }
-            const fwdName = (fwd.name ?? "").toLowerCase();
-            const target = (fwd.to ?? "").toLowerCase();
-            if (fwdName.includes("refund") || target.includes("refund")) {
-                hasRefundPath = true;
-            }
-            if (fwdName.includes("arb") || target.includes("arb")) {
-                hasArbitrationPath = true;
+            const target = (fwd.to ?? "").trim().toLowerCase();
+            if (wonderNodeRegex.test(target)) {
+                hasWonderNode = true;
             }
-            if (fwdName.includes("milestone") || target.includes("milestone")) {
+            if (target.includes("milestone")) {
                 hasMilestone = true;
             }
         }
@@ -77,10 +80,18 @@ export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
             }
         }
     }
+    const hasArbitrationBinding = (serviceRaw?.arbitrations?.length ?? 0) > 0;
+    const compBalance = serviceRaw?.compensation_fund?.balance ?? 0n;
+    const hasArbRefundPath = hasArbitrationBinding && compBalance > 0n;
+    const allocators = serviceRaw?.order_allocators?.[0]?.allocators ?? [];
+    const hasRefundAllocator = allocators.some((a) => a.surplus_to === "order" || a.surplus_to === "Order");
+    const hasRefundPath = hasArbRefundPath || hasRefundAllocator;
     if (!hasRefundPath)
         riskSignals.push("no_refund_path");
-    if (!hasArbitrationPath)
-        riskSignals.push("no_arbitration_path");
+    if (!hasArbitrationBinding)
+        riskSignals.push("no_arbitration_binding");
+    if (hasDisputeAntiPattern)
+        riskSignals.push("dispute_anti_pattern");
     if (userOperable === 0)
         riskSignals.push("no_user_operable_path");
     if (deadEndNodes.length > 0)
@@ -94,7 +105,10 @@ export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
         provider_only_forwards: providerOnly,
         guard_gated_forwards: guardGated,
         has_refund_path: hasRefundPath,
-        has_arbitration_path: hasArbitrationPath,
+        has_arbitration_path: hasArbitrationBinding,
+        has_arbitration_binding: hasArbitrationBinding,
+        has_wonder_node: hasWonderNode,
+        has_dispute_anti_pattern: hasDisputeAntiPattern,
         has_milestone_nodes: hasMilestone,
         dead_end_nodes: deadEndNodes,
         terminal_nodes: terminalNodes,
@@ -251,7 +265,7 @@ export function assembleInfoPuzzle(serviceId, raw, depth = "evaluate") {
     let trustSignals;
     if (depth === "evaluate" || depth === "preorder" || depth === "monitor") {
         if (raw.machine_nodes) {
-            workflowAnalysis = assembleWorkflowAnalysis(raw.machine_nodes, raw.machine_published ?? false, raw.machine_paused ?? false);
+            workflowAnalysis = assembleWorkflowAnalysis(raw.machine_nodes, raw.machine_published ?? false, raw.machine_paused ?? false, raw.service);
         }
         else {
             gaps.push("machine_workflow");
@@ -283,19 +297,14 @@ export function assembleInfoPuzzle(serviceId, raw, depth = "evaluate") {
             gaps.push("market_context");
         }
     }
-    const expectedDimensions = depth === "browse" ? 1
-        : depth === "evaluate" ? 4
-            : depth === "preorder" ? 6
-                : 4;
-    const actualDimensions = [
-        serviceBasics,
-        workflowAnalysis,
-        fundSafety,
-        trustSignals,
-        merchantBehavior,
-        marketContext,
-    ].filter((d) => d !== undefined && d !== null).length;
-    const completeness = Math.min(1, actualDimensions / expectedDimensions);
+    let userMetrics;
+    if (raw.user_metrics_config && raw.user_metrics_config.metrics.length > 0) {
+        userMetrics = assembleUserMetrics(raw.user_metrics_config, raw.user_metrics_context ?? {});
+    }
+    let serviceNesting = raw.service_nesting;
+    if (!serviceNesting && raw.service_nesting_raw) {
+        serviceNesting = evaluateServiceNesting(raw.service_nesting_raw);
+    }
     return {
         service_id: serviceId,
         service_basics: serviceBasics,
@@ -304,9 +313,341 @@ export function assembleInfoPuzzle(serviceId, raw, depth = "evaluate") {
         trust_signals: trustSignals,
         merchant_behavior: merchantBehavior,
         market_context: marketContext,
-        completeness,
+        user_metrics: userMetrics,
+        service_nesting: serviceNesting,
+        completeness: computeCompleteness(depth, [
+            serviceBasics,
+            workflowAnalysis,
+            fundSafety,
+            trustSignals,
+            merchantBehavior,
+            marketContext,
+            userMetrics,
+            serviceNesting,
+        ]),
         gaps,
         assembled_at: Date.now(),
     };
 }
+export function assembleUserMetrics(config, context) {
+    const cap = config.adjustment_cap ?? 10;
+    const results = [];
+    const totalWeight = config.metrics.reduce((sum, m) => sum + Math.max(0, m.weight), 0);
+    for (const metric of config.metrics) {
+        const normalizedWeight = totalWeight > 0 ? Math.max(0, metric.weight) / totalWeight : 0;
+        const observed = resolvePath(context, metric.params.path ?? metric.name);
+        const { passed, score, observed_value } = evaluateMetric(metric, observed);
+        results.push({
+            name: metric.name,
+            label: metric.label,
+            passed,
+            score,
+            observed_value: formatObservedValue(observed),
+            weight: normalizedWeight,
+            advice: passed
+                ? metric.advice_on_pass
+                : metric.advice_on_fail,
+        });
+    }
+    const aggregated = results.reduce((sum, r) => sum + r.score * r.weight, 0);
+    const score = Math.round(aggregated * 100);
+    const adjustment = Math.round(((score - 50) / 50) * cap);
+    return {
+        metrics: results,
+        score,
+        adjustment,
+        source_file: config.source_file,
+        evaluated_at: Date.now(),
+    };
+}
+function resolvePath(obj, path) {
+    if (!path)
+        return undefined;
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function evaluateMetric(metric, observed) {
+    const p = metric.params;
+    switch (metric.evaluator) {
+        case "threshold": {
+            const v = typeof observed === "number" ? observed
+                : typeof observed === "string" ? Number(observed)
+                    : typeof observed === "bigint" ? Number(observed)
+                        : NaN;
+            const threshold = typeof p.threshold === "number" ? p.threshold
+                : typeof p.threshold === "string" ? Number(p.threshold)
+                    : NaN;
+            if (isNaN(v) || isNaN(threshold)) {
+                return { passed: false, score: 0, observed_value: observed };
+            }
+            const passed = p.invert ? v <= threshold : v >= threshold;
+            const margin = Math.abs(threshold) * 0.5 || 1;
+            const rawScore = p.invert
+                ? (threshold - v) / margin + 1
+                : (v - threshold) / margin + 1;
+            const score = Math.max(0, Math.min(1, rawScore));
+            return { passed, score, observed_value: observed };
+        }
+        case "ratio": {
+            const v = typeof observed === "number" ? observed
+                : typeof observed === "string" ? Number(observed)
+                    : NaN;
+            const min = p.min ?? 0;
+            const max = p.max ?? 1;
+            if (isNaN(v)) {
+                return { passed: false, score: 0, observed_value: observed };
+            }
+            const passed = v >= min && v <= max;
+            const range = max - min;
+            const mid = (min + max) / 2;
+            const score = range > 0 ? Math.max(0, 1 - Math.abs(v - mid) / (range / 2)) : 1;
+            return { passed, score, observed_value: observed };
+        }
+        case "boolean": {
+            const passed = !!observed;
+            return { passed, score: passed ? 1 : 0, observed_value: observed };
+        }
+        case "presence": {
+            const present = observed !== undefined && observed !== null && observed !== "";
+            return { passed: present, score: present ? 1 : 0, observed_value: observed };
+        }
+        case "regex_match": {
+            if (typeof observed !== "string" || !p.pattern) {
+                return { passed: false, score: 0, observed_value: observed };
+            }
+            try {
+                const regex = new RegExp(p.pattern);
+                const passed = regex.test(observed);
+                return { passed, score: passed ? 1 : 0, observed_value: observed };
+            }
+            catch {
+                return { passed: false, score: 0, observed_value: observed };
+            }
+        }
+        case "custom_query": {
+            return { passed: false, score: 0.5, observed_value: observed };
+        }
+        default:
+            return { passed: false, score: 0, observed_value: observed };
+    }
+}
+function formatObservedValue(v) {
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+        return v;
+    if (typeof v === "bigint")
+        return v.toString();
+    if (v === undefined || v === null)
+        return undefined;
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+function computeCompleteness(depth, dimensions) {
+    const requiredCount = depth === "browse" ? 1
+        : depth === "evaluate" ? 4
+            : depth === "preorder" ? 6
+                : 5;
+    const requiredDimensions = dimensions.slice(0, requiredCount);
+    const presentCount = requiredDimensions.filter((d) => d !== undefined && d !== null).length;
+    return Math.min(1, presentCount / requiredCount);
+}
+export function evaluateServiceNesting(raw) {
+    const depth = raw.depth ?? 0;
+    const maxDepth = raw.maxDepth ?? 3;
+    const truncated = depth >= maxDepth;
+    const bindings = {
+        arbitrations: [],
+        rewards: [],
+        repositories: [],
+    };
+    let totalEvaluated = 0;
+    if (raw.machine) {
+        const m = raw.machine;
+        const issues = [];
+        let score = 0;
+        if (m.published)
+            score += 10;
+        else
+            issues.push("Machine not published");
+        if (m.paused) {
+            score += 40;
+            issues.push("Machine paused");
+        }
+        if (m.has_no_entry) {
+            score += 50;
+            issues.push("No entry point (R-M1-01)");
+        }
+        if (m.has_no_terminal) {
+            score += 50;
+            issues.push("No terminal node (R-M1-02)");
+        }
+        if (m.has_dispute_anti_pattern) {
+            score += 60;
+            issues.push("Dispute anti-pattern (R-M1-11): machine illegally models dispute flow");
+        }
+        const structIssues = m.structural_issue_count ?? 0;
+        if (structIssues > 0) {
+            score += structIssues * 15;
+            issues.push(`${structIssues} structural issue(s) detected (cycles/dead-ends/orphans)`);
+        }
+        score = Math.min(100, score);
+        bindings.machine = {
+            object_id: m.object_id,
+            published: m.published,
+            risk_level: scoreToNestingLevel(score),
+            issues,
+        };
+        totalEvaluated++;
+    }
+    for (const arb of raw.arbitrations ?? []) {
+        const issues = [];
+        let score = 0;
+        if (arb.voting_guard_count === 0) {
+            score += 50;
+            issues.push("No voting_guard configured — no arbitrators can vote");
+        }
+        else if (arb.voting_guard_count <= 2) {
+            score += 30;
+            issues.push("Few arbitrators (<=2) — limited dispute resolution capacity");
+        }
+        else {
+            score += 10;
+        }
+        if (arb.paused) {
+            score += 40;
+            issues.push("Arbitration paused — disputes cannot be filed");
+        }
+        if (arb.fee_balance === 0n) {
+            score += 30;
+            issues.push("No compensation fund balance — rulings cannot pay out");
+        }
+        score = Math.min(100, score);
+        bindings.arbitrations.push({
+            object_id: arb.object_id,
+            voting_guard_count: arb.voting_guard_count,
+            fee_balance: arb.fee_balance.toString(),
+            paused: arb.paused,
+            risk_level: scoreToNestingLevel(score),
+            issues,
+        });
+        totalEvaluated++;
+    }
+    for (const r of raw.rewards ?? []) {
+        const issues = [];
+        let score = 0;
+        if (r.balance === 0n) {
+            score += 60;
+            issues.push("Reward fund empty — claims will fail");
+        }
+        if (r.guard_count === 0) {
+            score += 50;
+            issues.push("No claim_guard — anyone could claim (or no one can, depending on default)");
+        }
+        if (r.expiration_time && r.expiration_time > 0 && r.expiration_time < Date.now()) {
+            score += 40;
+            issues.push("Reward expired — claims no longer possible");
+        }
+        score = Math.min(100, score);
+        bindings.rewards.push({
+            object_id: r.object_id,
+            balance: r.balance.toString(),
+            guard_count: r.guard_count,
+            risk_level: scoreToNestingLevel(score),
+            issues,
+        });
+        totalEvaluated++;
+    }
+    for (const repo of raw.repositories ?? []) {
+        const issues = [];
+        let score = 0;
+        if (!repo.has_write_guard) {
+            score += 40;
+            issues.push("No write_guard — Repository is open to arbitrary writes");
+        }
+        if (repo.is_empty) {
+            score += 20;
+            issues.push("Repository empty — no historical data for evaluation");
+        }
+        score = Math.min(100, score);
+        bindings.repositories.push({
+            object_id: repo.object_id,
+            risk_level: scoreToNestingLevel(score),
+            issues,
+        });
+        totalEvaluated++;
+    }
+    if (totalEvaluated === 0) {
+        return undefined;
+    }
+    const machineScore = bindings.machine ? nestingLevelToScore(bindings.machine.risk_level) : 0;
+    const machineWeight = bindings.machine ? 35 : 0;
+    const arbScore = bindings.arbitrations.length > 0
+        ? Math.max(...bindings.arbitrations.map((a) => nestingLevelToScore(a.risk_level)))
+        : 0;
+    const arbWeight = bindings.arbitrations.length > 0 ? 30 : 0;
+    const rewardScore = bindings.rewards.length > 0
+        ? Math.max(...bindings.rewards.map((r) => nestingLevelToScore(r.risk_level)))
+        : 0;
+    const rewardWeight = bindings.rewards.length > 0 ? 20 : 0;
+    const repoScore = bindings.repositories.length > 0
+        ? Math.max(...bindings.repositories.map((r) => nestingLevelToScore(r.risk_level)))
+        : 0;
+    const repoWeight = bindings.repositories.length > 0 ? 15 : 0;
+    const totalWeight = machineWeight + arbWeight + rewardWeight + repoWeight;
+    const overallScore = totalWeight > 0
+        ? Math.round((machineScore * machineWeight + arbScore * arbWeight
+            + rewardScore * rewardWeight + repoScore * repoWeight) / totalWeight)
+        : 0;
+    const allLevels = [];
+    if (bindings.machine)
+        allLevels.push(bindings.machine.risk_level);
+    for (const a of bindings.arbitrations)
+        allLevels.push(a.risk_level);
+    for (const r of bindings.rewards)
+        allLevels.push(r.risk_level);
+    for (const r of bindings.repositories)
+        allLevels.push(r.risk_level);
+    const overallLevel = allLevels.reduce(highestLevel, "low");
+    return {
+        depth_reached: depth,
+        truncated,
+        bindings,
+        overall_risk_level: overallLevel,
+        overall_risk_score: overallScore,
+        total_bindings_evaluated: totalEvaluated,
+        evaluated_at: Date.now(),
+    };
+}
+function scoreToNestingLevel(score) {
+    if (score >= 75)
+        return "critical";
+    if (score >= 50)
+        return "high";
+    if (score >= 25)
+        return "medium";
+    return "low";
+}
+function nestingLevelToScore(level) {
+    switch (level) {
+        case "critical": return 90;
+        case "high": return 65;
+        case "medium": return 40;
+        case "low": return 10;
+    }
+}
+function highestLevel(a, b) {
+    const order = { low: 0, medium: 1, high: 2, critical: 3 };
+    return order[a] >= order[b] ? a : b;
+}
 export { CUSTOMER_INTELLIGENCE_VERSION };