@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/tools/handlers/project.js

@@ -3,10 +3,16 @@ import { generateDeploymentDocFromProject } from "../../project/deployment-bridg
 import { LocalProject } from "@wowok/wowok";
 import { validateStageGate } from "../../project/stage-gate.js";
 import { scanDeployment } from "../../knowledge/deployment-scanner.js";
-import { handleListProjects, handleCreateProject, handleCreateProjectFromOnchain, handleUpdateProject, handleGetProjectDetail, handleAddObject, handleRemoveObject, handleUpdateObject, handleCreateVersion, handleBuildGraph, handleGetGraph, handleEvaluateProject, handleSaveEvaluation, handleCompareProjects, handleRefreshObjects, handleGetObjectDiff, handleDeleteProject, handleGetMachineGraph, handlePreEvaluateCheck, handleVerifyDeployment, handleCloneProjectToNetwork, } from "../../project/handlers.js";
+import { handleListProjects, handleCreateProject, handleCreateProjectFromOnchain, handleUpdateProject, handleGetProjectDetail, handleAddObject, handleRemoveObject, handleUpdateObject, handleCreateVersion, handleBuildGraph, handleGetGraph, handleEvaluateProject, handleSaveEvaluation, handleCompareProjects, handleRefreshObjects, handleGetObjectDiff, handleDeleteProject, handleGetMachineGraph, handleGetGuardGraph, handlePreEvaluateCheck, handleVerifyDeployment, handleCloneProjectToNetwork, handleMigrateToMainnet, } from "../../project/handlers.js";
+import { handlePlanObjectEdit, handleApplyObjectEdit, handlePatchMachineNodes, handlePatchGuardTree, } from "../../project/edit-planner.js";
+import { handleRecommendIndustry, handleListModes, handleDeriveUserMode, handleEvolveUserMode, handleRegisterUserMode, handleUnregisterUserMode, handleRegisterCustomMetric, handleRegisterCustomConstraint, handleListMetricsConstraints, } from "../../project/mode-actions.js";
+import { handleAnalyzeIntent, handleAggregateRisks, handleTraceSubsteps, } from "../../project/pipeline-actions.js";
+import { handleMerchantGuide } from "../../project/merchant-guide.js";
+import { handleParticipationRadar } from "../../project/participation-radar.js";
 import { strictParse } from "../../schema/index.js";
 import { ProjectOperationInputSchema } from "../../schema/project/index.js";
 import { getStageCache } from "../../project/index.js";
+import { getSkillsHintForProject } from "../../schema/utils/skills-recommendation.js";
 export async function handleProjectOperation(args) {
     const validated = strictParse(ProjectOperationInputSchema, args, "project_operation input");
     const { action } = validated;
@@ -66,6 +72,9 @@ export async function handleProjectOperation(args) {
         case "get_machine_graph":
             result = await handleGetMachineGraph(validated);
             break;
+        case "get_guard_graph":
+            result = await handleGetGuardGraph(validated);
+            break;
         case "assemble_context":
             result = await assembleContext(validated);
             break;
@@ -132,11 +141,71 @@ export async function handleProjectOperation(args) {
         case "migrate_network":
             result = await handleCloneProjectToNetwork(validated);
             break;
+        case "migrate_to_mainnet":
+            result = await handleMigrateToMainnet(validated);
+            break;
+        case "plan_object_edit":
+            result = await handlePlanObjectEdit(validated);
+            break;
+        case "apply_object_edit":
+            result = await handleApplyObjectEdit(validated);
+            break;
+        case "patch_machine_nodes":
+            result = await handlePatchMachineNodes(validated);
+            break;
+        case "patch_guard_tree":
+            result = await handlePatchGuardTree(validated);
+            break;
+        case "recommend_industry":
+            result = handleRecommendIndustry(validated);
+            break;
+        case "list_modes":
+            result = await handleListModes();
+            break;
+        case "derive_user_mode":
+            result = await handleDeriveUserMode(validated);
+            break;
+        case "evolve_user_mode":
+            result = await handleEvolveUserMode(validated);
+            break;
+        case "register_user_mode":
+            result = await handleRegisterUserMode(validated);
+            break;
+        case "unregister_user_mode":
+            result = await handleUnregisterUserMode(validated);
+            break;
+        case "register_custom_metric":
+            result = handleRegisterCustomMetric(validated);
+            break;
+        case "register_custom_constraint":
+            result = handleRegisterCustomConstraint(validated);
+            break;
+        case "list_metrics_constraints":
+            result = handleListMetricsConstraints(validated);
+            break;
+        case "analyze_intent":
+            result = handleAnalyzeIntent(validated);
+            break;
+        case "aggregate_risks":
+            result = handleAggregateRisks(validated);
+            break;
+        case "trace_substeps":
+            result = handleTraceSubsteps(validated);
+            break;
+        case "merchant_guide":
+            result = await handleMerchantGuide(validated);
+            break;
+        case "participation_radar":
+            result = await handleParticipationRadar(validated);
+            break;
         default:
             throw new Error(`Unknown project_operation action: ${String(action)}`);
     }
+    const skillsHint = getSkillsHintForProject(action);
     return {
         content: [{ type: "text", text: JSON.stringify({ result }) }],
-        structuredContent: { result },
+        structuredContent: skillsHint
+            ? { result, skills_recommended: skillsHint }
+            : { result },
     };
 }

package/dist/tools/handlers/query.js

@@ -1,7 +1,46 @@
 import { strictParse, WatchQueryOperationsSchema, OnchainTableDataSchema, OnchainEventsInputSchema, ProtocolInfoQuerySchema, } from "../../schema/index.js";
 import { query_local_mark_list, query_account_list, query_local_info_list, query_local_token_list, query_account, GetLocalNamesByAddresses, query_personal, query_objects, query_table, query_tableItem, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_received, queryProtocolInfo, query_events, query_transaction, query_object_history, query_address_activity, generateNodeComments, } from "@wowok/wowok";
 import { buildDataSemantic, } from "../../schema/call/semantic.js";
+import { formatChainValue, annotateObjectMonetaryFields, annotateTableItemMonetaryFields, annotateEventsMonetaryFields, annotateBalanceChanges, resolveParentObjectTokenType, convertTokenValue, } from "../../knowledge/fund-layer.js";
 import { normalizeAccountOrMark } from "./messenger.js";
+async function annotateAccountBalance(result, network) {
+    if (!result || typeof result !== "object")
+        return;
+    const displays = {};
+    const convert = (raw, coinType) => {
+        if (raw === null || raw === undefined)
+            return undefined;
+        if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "bigint")
+            return undefined;
+        if (typeof coinType !== "string" || !coinType)
+            return undefined;
+        return formatChainValue(raw, coinType, network);
+    };
+    const balance = result.balance;
+    if (balance && typeof balance === "object") {
+        const coinType = balance.coinType;
+        const total = await convert(balance.totalBalance, coinType);
+        if (total)
+            displays["balance.totalBalance"] = total;
+        if (balance.lockedBalance !== undefined) {
+            const locked = await convert(balance.lockedBalance, coinType);
+            if (locked)
+                displays["balance.lockedBalance"] = locked;
+        }
+    }
+    const coinData = result.coin?.data;
+    if (Array.isArray(coinData)) {
+        for (let i = 0; i < coinData.length; i++) {
+            const c = coinData[i];
+            const d = await convert(c?.balance, c?.coinType);
+            if (d)
+                displays[`coin.data[${i}].balance`] = d;
+        }
+    }
+    if (Object.keys(displays).length > 0) {
+        result._money_display = displays;
+    }
+}
 export async function handleWatchQueryOperations(args) {
     const validated = strictParse(WatchQueryOperationsSchema, args, "watch_and_query input");
     let result;
@@ -34,6 +73,7 @@ export async function handleWatchQueryOperations(args) {
                 coin: validated.coin,
                 network: validated.network,
             });
+            await annotateAccountBalance(queryResult, validated.network);
             result = { query_type: "account_balance", result: queryResult };
             break;
         }
@@ -100,6 +140,13 @@ export async function handleWatchQueryOperations(args) {
                     }
                     return obj;
                 });
+                for (const obj of queryResult.objects) {
+                    try {
+                        await annotateObjectMonetaryFields(obj, validated.network);
+                    }
+                    catch {
+                    }
+                }
             }
             result = { query_type: "onchain_objects", result: queryResult };
             break;
@@ -113,7 +160,37 @@ export async function handleWatchQueryOperations(args) {
                 no_cache: validated.no_cache,
                 network: validated.network,
             });
-            result = { query_type: "onchain_received", result: queryResult };
+            const qr = queryResult;
+            if (qr && typeof qr === "object" && typeof qr.balance === "bigint") {
+                const tokenType = qr.token_type;
+                qr.balance = qr.balance.toString();
+                if (Array.isArray(qr.received)) {
+                    for (const item of qr.received) {
+                        if (item && typeof item.balance === "bigint") {
+                            item.balance = item.balance.toString();
+                        }
+                    }
+                }
+                if (tokenType) {
+                    try {
+                        const displays = {
+                            balance: await formatChainValue(qr.balance, tokenType, validated.network),
+                        };
+                        if (Array.isArray(qr.received)) {
+                            for (let i = 0; i < qr.received.length; i++) {
+                                const b = qr.received[i]?.balance;
+                                if (b !== undefined && b !== null) {
+                                    displays[`received[${i}].balance`] = await formatChainValue(b, tokenType, validated.network);
+                                }
+                            }
+                        }
+                        qr._money_display = displays;
+                    }
+                    catch {
+                    }
+                }
+            }
+            result = { query_type: "onchain_received", result: qr };
             break;
         }
         case "onchain_transaction": {
@@ -122,6 +199,11 @@ export async function handleWatchQueryOperations(args) {
                 no_cache: validated.no_cache,
                 network: validated.network,
             });
+            try {
+                await annotateBalanceChanges(queryResult?.balance_changes, validated.network);
+            }
+            catch {
+            }
             result = { query_type: "onchain_transaction", result: queryResult };
             break;
         }
@@ -152,8 +234,20 @@ export async function handleWatchQueryOperations(args) {
             result = { query_type: "onchain_address_activity", result: queryResult };
             break;
         }
+        case "token_value_convert": {
+            const hasRaw = validated.raw !== undefined;
+            const hasUnit = validated.unit !== undefined;
+            if (hasRaw === hasUnit) {
+                throw new Error(`token_value_convert: provide EXACTLY ONE of 'raw' (u64 smallest units → unit value) ` +
+                    `or 'unit' (unit value → u64 raw). Received raw=${JSON.stringify(validated.raw)}, ` +
+                    `unit=${JSON.stringify(validated.unit)}.`);
+            }
+            const conversion = await convertTokenValue(validated.token_type, hasRaw ? { raw: validated.raw } : { unit: validated.unit }, validated.network);
+            result = { query_type: "token_value_convert", result: conversion };
+            break;
+        }
         default:
-            throw new Error(`Unknown query type. Valid query_types are: "local_mark_list", "account_list", "local_info_list", "token_list", "account_balance", "local_names", "onchain_personal_profile", "onchain_objects", "onchain_received", "onchain_transaction", "onchain_object_history", "onchain_address_activity". For table queries, use the "onchain_table_data" tool.`);
+            throw new Error(`Unknown query type. Valid query_types are: "local_mark_list", "account_list", "local_info_list", "token_list", "account_balance", "local_names", "onchain_personal_profile", "onchain_objects", "onchain_received", "onchain_transaction", "onchain_object_history", "onchain_address_activity", "token_value_convert". For table queries, use the "onchain_table_data" tool.`);
     }
     return {
         content: [{ type: "text", text: JSON.stringify({ result }) }],
@@ -202,6 +296,14 @@ export async function handleOnchainTableData(args) {
                 parent: validated.parent, address: validated.address,
                 no_cache: validated.no_cache, network: validated.network,
             });
+            if (queryResult) {
+                try {
+                    const parentToken = await resolveParentObjectTokenType(validated.parent, validated.network);
+                    await annotateTableItemMonetaryFields(queryResult, parentToken, validated.network);
+                }
+                catch {
+                }
+            }
             result = { query_type: "onchain_table_item_reward_record", result: queryResult };
             break;
         }
@@ -218,6 +320,14 @@ export async function handleOnchainTableData(args) {
                 parent: validated.parent, address: validated.address,
                 no_cache: validated.no_cache, network: validated.network,
             });
+            if (queryResult) {
+                try {
+                    const parentToken = await resolveParentObjectTokenType(validated.parent, validated.network);
+                    await annotateTableItemMonetaryFields(queryResult, parentToken, validated.network);
+                }
+                catch {
+                }
+            }
             result = { query_type: "onchain_table_item_treasury_history", result: queryResult };
             break;
         }
@@ -298,6 +408,11 @@ export async function handleOnchainEvents(args) {
         no_cache: validated.no_cache,
         network: validated.network,
     });
+    try {
+        await annotateEventsMonetaryFields(queryResult?.data, validated.network);
+    }
+    catch {
+    }
     return {
         content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
         structuredContent: {

package/dist/tools/handlers/schema-query.js

@@ -1,4 +1,4 @@
-import { processSchemaQuery, } from "../../schema-query/index.js";
+import { processSchemaQuery, EXAMPLES_DIR, } from "../../schema-query/index.js";
 import { strictParse } from "../../schema/index.js";
 import { SchemaQueryInputSchema } from "../../schema/schema-query/index.js";
 export async function handleSchemaQuery(args) {
@@ -9,6 +9,8 @@ export async function handleSchemaQuery(args) {
         query: validated.query,
         field_path: validated.field_path,
         template: validated.template,
+        object_type: validated.object_type,
+        params: validated.params,
         output_file: validated.output_file,
     };
     const response = processSchemaQuery(request);
@@ -92,6 +94,68 @@ export async function handleSchemaQuery(args) {
                     textContent += "\n\nNo schemas found. Try 'list' to browse all available schemas, or use a broader search term.";
                 }
                 break;
+            case "search_examples": {
+                const items = (Array.isArray(data) ? data : []);
+                if (items.length > 0) {
+                    textContent += `\n\nFound ${items.length} example(s) matching '${request.query ?? ""}':\n`;
+                    for (const item of items) {
+                        textContent += `\n  • [score: ${item.score}] ${item.file}`;
+                        textContent += `\n    Title: ${item.title}`;
+                        textContent += `\n    Industry: ${item.industry} | Operation: ${item.operation_type} | Verified: ${item.verified ? "yes" : "no"}`;
+                        textContent += `\n    Tags: ${item.tags.join(", ")}`;
+                        textContent += `\n    Matched fields: ${item.matched_fields.join(", ")}`;
+                        const descPreview = item.description.length > 120
+                            ? `${item.description.slice(0, 120)}...`
+                            : item.description;
+                        textContent += `\n    Description: ${descPreview}`;
+                        textContent += "\n";
+                    }
+                    textContent += `\n  To view the full example JSON, read files from: ${EXAMPLES_DIR}`;
+                }
+                else {
+                    textContent += "\n\nNo examples found. Try broader terms like 'service', 'machine', 'guard', 'permission', or an industry name like 'rental' or 'retail'.";
+                }
+                break;
+            }
+            case "get_tool_reference": {
+                textContent += "\n\n## MCP Tool Reference\n\n";
+                textContent += "```json\n";
+                textContent += JSON.stringify(data, null, 2);
+                textContent += "\n```\n";
+                break;
+            }
+            case "get_guard_design_patterns": {
+                textContent += "\n\n## Guard Design Patterns\n\n";
+                textContent += "```json\n";
+                textContent += JSON.stringify(data, null, 2);
+                textContent += "\n```\n";
+                break;
+            }
+            case "get_safety_rules": {
+                textContent += "\n\n## Safety Rules (sunk from wowok-safety skill)\n\n";
+                textContent += "```json\n";
+                textContent += JSON.stringify(data, null, 2);
+                textContent += "\n```\n";
+                break;
+            }
+            case "get_templates": {
+                textContent += "\n\n## Unified Template Registry (92-review D.2)\n\n";
+                const listData = data;
+                if (Array.isArray(listData.templates) && !request.template) {
+                    textContent += `\n${listData.total ?? listData.templates.length} template(s). `;
+                    textContent += "Call with 'template'=<id> for detail; add 'params' (JSON string) to instantiate.\n";
+                    for (const t of listData.templates) {
+                        textContent += `\n  • ${t.id} [${t.object_type}${t.instantiable ? "" : ", guidance-only"}] — ${t.name} (${t.parameters?.length ?? 0} params)`;
+                    }
+                    textContent += "\n";
+                }
+                else {
+                    textContent += "```json\n";
+                    textContent += JSON.stringify(data, null, 2);
+                    textContent += "\n```\n";
+                }
+                break;
+            }
             default:
                 throw new Error(`Unknown schema_query action: ${String(request.action)}`);
         }

package/dist/tools/handlers/trust.js

@@ -1,7 +1,8 @@
 import { strictParse, TrustScoreInputSchema, } from "../../schema/index.js";
-import { query_objects, } from "@wowok/wowok";
+import { query_objects, query_personal, } from "@wowok/wowok";
 import { computeServiceTrustScore, } from "../../knowledge/index.js";
-import { assembleInfoPuzzle, assessRisk, } from "../../customer/index.js";
+import { assembleInfoPuzzle, assemblePreorderAdvice, assessRisk, buildPreorderComparison, getDefaultPreferences, inferIndustry, mergePreferences, validatePreferences, } from "../../customer/index.js";
+import { getProfile } from "../../experience/user-profile.js";
 function extractTrustMetrics(serviceObj) {
     const data = serviceObj?.data ?? serviceObj ?? {};
     const sales = Array.isArray(data.sales) ? data.sales : [];
@@ -113,8 +114,75 @@ function extractBalance(b) {
     }
     return 0n;
 }
-export async function handleTrustScore(args) {
-    const validated = strictParse(TrustScoreInputSchema, args, "trust_score input");
+function toUserMetricsConfig(input) {
+    return {
+        version: 1,
+        metrics: input.metrics.map((m) => ({
+            name: m.name,
+            label: m.label,
+            evaluator: m.evaluator,
+            params: {
+                ...m.params,
+                threshold: m.params.threshold !== undefined ? String(m.params.threshold) : undefined,
+            },
+            weight: m.weight,
+            advice_on_fail: m.advice_on_fail,
+            advice_on_pass: m.advice_on_pass,
+        })),
+        adjustment_cap: input.adjustment_cap,
+    };
+}
+function derivePreferences(validated, industry) {
+    const profile = getProfile();
+    const withProfile = mergePreferences(getDefaultPreferences(industry), {
+        risk_appetite: profile.risk_appetite,
+        min_trust_score: profile.risk_appetite === "conservative" ? 70
+            : profile.risk_appetite === "aggressive" ? 30 : 50,
+    });
+    const manualInput = validated.preferences;
+    const manual = manualInput
+        ? {
+            ...manualInput,
+            budget_range: manualInput.budget_range
+                ? {
+                    min: BigInt(manualInput.budget_range.min),
+                    max: BigInt(manualInput.budget_range.max),
+                }
+                : undefined,
+        }
+        : undefined;
+    const prefs = manual ? mergePreferences(withProfile, manual) : withProfile;
+    return { prefs, issues: validatePreferences(prefs) };
+}
+async function fetchMerchantReputation(permissionAddr, network, noCache) {
+    try {
+        if (typeof permissionAddr !== "string" || !permissionAddr.startsWith("0x")) {
+            return undefined;
+        }
+        const permResult = await query_objects({
+            objects: [permissionAddr],
+            no_cache: noCache,
+            network,
+        });
+        const permObj = permResult?.objects?.[0];
+        const builder = (permObj?.data ?? permObj)?.builder;
+        if (typeof builder !== "string" || !builder.startsWith("0x")) {
+            return undefined;
+        }
+        const personal = await query_personal({
+            account: builder,
+            no_cache: noCache,
+            network,
+        });
+        if (!personal)
+            return undefined;
+        return { likes: personal.like ?? 0, dislikes: personal.dislike ?? 0 };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function runTrustEvaluation(validated) {
     const depth = (validated.depth ?? "evaluate");
     const queryResult = await query_objects({
         objects: [validated.service],
@@ -142,11 +210,50 @@ export async function handleTrustScore(args) {
         : salePriceRaw;
     let riskScore;
     let infoPuzzle;
+    let preorderAdvice;
+    let preferenceIssues;
     if (depth === "evaluate" || depth === "preorder") {
         const puzzleRaw = buildPuzzleRawData(serviceObj, orderAmount, { score: trustScore.score, level: trustScore.level }, undefined);
+        if (validated.user_metrics) {
+            puzzleRaw.user_metrics_config = toUserMetricsConfig(validated.user_metrics);
+        }
+        if (depth === "preorder") {
+            const reputation = await fetchMerchantReputation((serviceObj?.data ?? serviceObj)?.permission, validated.network, validated.no_cache);
+            if (reputation)
+                puzzleRaw.merchant_reputation = reputation;
+        }
         infoPuzzle = assembleInfoPuzzle(validated.service, puzzleRaw, depth);
         riskScore = assessRisk(infoPuzzle);
+        if (depth === "preorder") {
+            const industry = validated.industry ?? inferIndustry(infoPuzzle);
+            const { prefs, issues } = derivePreferences(validated, industry);
+            preferenceIssues = issues.length > 0 ? issues : undefined;
+            preorderAdvice = assemblePreorderAdvice({
+                puzzle: infoPuzzle,
+                risk: riskScore,
+                preferences: prefs,
+                industry,
+            });
+        }
     }
+    return {
+        serviceId: validated.service,
+        serviceName: serviceObj?.data?.name ?? serviceObj?.name ?? validated.service,
+        serviceObj,
+        sales,
+        trustScore,
+        orderAmount,
+        infoPuzzle,
+        riskScore,
+        preorderAdvice,
+        preferenceIssues,
+    };
+}
+export async function handleTrustScore(args) {
+    const validated = strictParse(TrustScoreInputSchema, args, "trust_score input");
+    const depth = (validated.depth ?? "evaluate");
+    const core = await runTrustEvaluation(validated);
+    const { serviceObj, sales, trustScore, orderAmount, infoPuzzle, riskScore, preorderAdvice, preferenceIssues } = core;
     const result = {
         service_id: validated.service,
         service_name: serviceObj?.data?.name ?? serviceObj?.name ?? validated.service,
@@ -186,9 +293,88 @@ export async function handleTrustScore(args) {
                 assembled_at: infoPuzzle.assembled_at,
             },
         } : {}),
+        ...(preorderAdvice ? {
+            preorder_advice: {
+                confidence: preorderAdvice.confidence,
+                industry: preorderAdvice.industry,
+                strategies: preorderAdvice.strategies.map((s) => ({
+                    scenario: s.scenario,
+                    merchant_tactic: s.strategy.merchant_tactic,
+                    user_strategy: s.strategy.user_strategy,
+                    nash_equilibrium: s.strategy.nash_equilibrium,
+                    confidence: s.confidence,
+                    fallback: s.fallback,
+                    rationale: s.rationale,
+                })),
+                ...(preorderAdvice.preference_match
+                    ? { preference_match: preorderAdvice.preference_match }
+                    : {}),
+                ...(preferenceIssues ? { preference_issues: preferenceIssues } : {}),
+                ...(preorderAdvice.industry_risks
+                    ? {
+                        industry_risks: {
+                            score_adjustment: preorderAdvice.industry_risks.score_adjustment,
+                            summary: preorderAdvice.industry_risks.summary,
+                            checks: preorderAdvice.industry_risks.checks,
+                            unmet_needs: preorderAdvice.industry_risks.unmet_needs.map((n) => ({
+                                id: n.id,
+                                tier: n.tier,
+                                description: n.description,
+                                advice: n.advice,
+                            })),
+                        },
+                    }
+                    : {}),
+                reminders: preorderAdvice.reminders,
+                blocking_reminders: preorderAdvice.blocking_reminders,
+                summary: preorderAdvice.summary,
+            },
+        } : {}),
     };
+    let comparison;
+    if (depth === "preorder" && validated.compare_with && validated.compare_with.length > 0) {
+        const rows = [coreToCompareRow(core)];
+        for (const candidate of validated.compare_with) {
+            try {
+                const candidateCore = await runTrustEvaluation({
+                    ...validated,
+                    service: candidate,
+                    depth: "preorder",
+                });
+                rows.push(coreToCompareRow(candidateCore));
+            }
+            catch (e) {
+                rows.push({
+                    service_id: candidate,
+                    service_name: candidate,
+                    error: e.message,
+                });
+            }
+        }
+        comparison = buildPreorderComparison(rows);
+    }
+    const finalResult = comparison ? { ...result, comparison } : result;
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result: finalResult }) }],
+        structuredContent: { result: finalResult },
+    };
+}
+function coreToCompareRow(core) {
+    const reputation = core.infoPuzzle?.merchant_behavior?.reputation;
     return {
-        content: [{ type: "text", text: JSON.stringify({ result }) }],
-        structuredContent: { result },
+        service_id: core.serviceId,
+        service_name: core.serviceName,
+        industry: core.preorderAdvice?.industry,
+        confidence: core.preorderAdvice?.confidence.score,
+        risk_total: core.riskScore?.total,
+        risk_level: core.riskScore?.level,
+        trust_score: core.trustScore.score,
+        trust_level: core.trustScore.level,
+        preference_match: core.preorderAdvice?.preference_match?.score,
+        reputation_like_ratio: reputation?.like_ratio,
+        reputation_votes: reputation ? reputation.likes + reputation.dislikes : undefined,
+        red_flags_count: core.riskScore?.red_flags.length,
+        blocking_reminders_count: core.preorderAdvice?.blocking_reminders.length,
+        info_gaps_count: core.infoPuzzle?.gaps.length,
     };
 }

package/dist/tools/index.d.ts

@@ -2,6 +2,14 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { ToolEntry, ToolDispatchResult, DispatchOptions } from "./types.js";
 export declare const TOOL_REGISTRY: ToolEntry[];
 export declare const TOOL_REGISTRY_MAP: Map<string, ToolEntry>;
+export interface StructuredSchemaError {
+    path: string;
+    code: string;
+    message: string;
+    expected?: string;
+    received_value?: unknown;
+    suggestion: string;
+}
 export declare function dispatchToolCall(name: string, args: unknown, options?: DispatchOptions): Promise<ToolDispatchResult>;
 export interface ToolListEntry {
     name: string;