@wowok/agent-mcp 2.3.16 → 2.3.18

package/dist/index.js

@@ -5,7 +5,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { readFileSync } from "fs";
 import { resolve } from "path";
 const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
-import { MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, BridgeOperationsSchema, BridgeCallOutputSchema, OnchainOperationsSchema, WipOperationsSchema, OnchainTableDataSchema, OnchainTableDataResultSchema, WatchQueryOperationsSchema, registerSuccessHook, } from "./schema/index.js";
+import { MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, BridgeOperationsSchema, BridgeCallOutputSchema, OnchainOperationsSchema, WipOperationsSchema, OnchainTableDataSchema, OnchainTableDataResultSchema, WatchQueryOperationsSchema, registerSuccessHook, SchemaQueryInputSchema, SchemaQueryOutputSchema, ProjectOperationInputSchema, ProjectOperationOutputSchema, ConfigOperationInputSchema, ConfigOperationOutputSchema, TrustScoreInputSchema, TrustScoreOutputSchema, checkClientSchemaCompatibility, } from "./schema/index.js";
 import { handleBridgeOperations } from "./schema/call/bridge-handler.js";
 import { buildDataSemantic, classifyError } from "./schema/call/semantic.js";
 import { getHarness } from "./harness/index.js";
@@ -13,7 +13,8 @@ import { confirmGate } from "./safety/confirm-gate.js";
 import { renderPreview } from "./safety/preview.js";
 import { isProjectServiceEnabled, normalize as projectNormalize, observe as projectObserve, queryProjects, queryProjectObjects, queryShareableObjects, queryDependencies, queryReferencedBy, queryPrePublishCheck, queryCrossProjectReferences, queryGraphStats, saveGraph, loadGraph, } from "./project/index.js";
 import { isEnabled as isRuntimeEnabled, listServices, getServiceInfo, toggle as toggleService, setEnabled as setServiceEnabled, reset as resetService, } from "./config/index.js";
-import { validateOperation, hasBlockingViolations, getWarningViolations, } from "./knowledge/index.js";
+import { validateOperation, hasBlockingViolations, getWarningViolations, computeServiceTrustScore, } from "./knowledge/index.js";
+import { assembleInfoPuzzle, assessRisk, } from "./customer/index.js";
 const HARNESS_ENABLED = () => isRuntimeEnabled("harness");
 function withHarness(base, operation, intent) {
     if (!HARNESS_ENABLED())
@@ -84,7 +85,7 @@ function buildConstraintError(operation_type, violations) {
         structuredContent: output,
     };
 }
-import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, guard2file, parseGuardFile, formatGuardParseErrors, machineNode2file, generateNodeComments, generate_wip, verify_wip, sign_wip, wip2html, account_operation, local_mark_operation, local_info_operation, watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, pull_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, 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, queryProtocolInfo, query_received, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_events, blacklist, friendslist, guardlist, settings, AmountType, } from "@wowok/wowok";
+import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, guard2file, parseGuardFile, formatGuardParseErrors, machineNode2file, generateNodeComments, generate_wip, verify_wip, sign_wip, wip2html, account_operation, local_mark_operation, local_info_operation, watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, pull_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, 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, queryProtocolInfo, query_received, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_events, blacklist, friendslist, guardlist, settings, transformRewardInput, transformPersonalInput, } from "@wowok/wowok";
 import { areSchemasAvailable, getSchemaIndex, processSchemaQuery, } from "./schema-query/index.js";
 const SERVER_DESCRIPTION = `WoWok MCP Server - Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.
 
@@ -266,38 +267,6 @@ function wrapHandlerWithErrorShape(handler, timeoutMs, toolName, errorShapeBuild
         }
     };
 }
-function convertAmountType(type) {
-    if (typeof type === "number")
-        return type;
-    const upperType = type.toUpperCase();
-    if (upperType === "GUARDU64IDENTIFIER" || upperType === "GUARD_U64_IDENTIFIER") {
-        return AmountType.GuardU64Identifier;
-    }
-    if (upperType === "FIXED") {
-        return AmountType.Fixed;
-    }
-    return AmountType.Fixed;
-}
-function transformRewardData(data) {
-    if (!data)
-        return data;
-    const transformed = { ...data };
-    if (transformed.guard_add && Array.isArray(transformed.guard_add)) {
-        transformed.guard_add = transformed.guard_add.map((guard) => {
-            if (guard.amount && typeof guard.amount.type === "string") {
-                return {
-                    ...guard,
-                    amount: {
-                        ...guard.amount,
-                        type: convertAmountType(guard.amount.type)
-                    }
-                };
-            }
-            return guard;
-        });
-    }
-    return transformed;
-}
 async function handleOnchainTableData(args) {
     const validated = strictParse(OnchainTableDataSchema, args, "onchain_table_data input");
     let result;
@@ -405,6 +374,17 @@ async function handleOnchainOperations(args) {
             return buildConstraintError(validated.operation_type, constraintViolations);
         }
         constraintWarnings = getWarningViolations(constraintViolations).map((v) => `[PRE-CHECK] ${v.message}`);
+        const clientSchemaVersion = env?.client_schema_version;
+        const schemaStrictMode = env?.schema_strict_mode;
+        const schemaCheck = clientSchemaVersion
+            ? checkClientSchemaCompatibility(clientSchemaVersion, { mode: schemaStrictMode ? "strict" : "warn" })
+            : undefined;
+        const buildCtx = (data) => ({
+            operation_type: validated.operation_type,
+            data,
+            pre_warnings: constraintWarnings.length ? constraintWarnings : undefined,
+            schema_check: schemaCheck,
+        });
         const projectEnvPrefix = env?.project;
         if (isProjectServiceEnabled()) {
             const pn = projectNormalize({
@@ -418,6 +398,8 @@ async function handleOnchainOperations(args) {
             delete env.confirmed;
             delete env.user_intent_phrases;
             delete env.project;
+            delete env.client_schema_version;
+            delete env.schema_strict_mode;
         }
         switch (validated.operation_type) {
             case "service": {
@@ -427,7 +409,7 @@ async function handleOnchainOperations(args) {
                     : await callService.call(env);
                 const data = validated.data;
                 const intent = data?.publish ? "publish service" : data?.bPublished !== undefined ? "modify service" : "create service";
-                return handleCallResult(result, withHarness({ operation_type: validated.operation_type, data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined }, "service", intent));
+                return handleCallResult(result, withHarness(buildCtx(data), "service", intent));
             }
             case "machine": {
                 if (validated.data.node && typeof validated.data.node === 'object' && 'json_or_markdown_file' in validated.data.node) {
@@ -458,62 +440,62 @@ async function handleOnchainOperations(args) {
                 const result = validated.submission
                     ? await callMachine.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callMachine.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "progress": {
                 const callProgress = new CallProgress(validated.data);
                 const result = validated.submission
                     ? await callProgress.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callProgress.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "repository": {
                 const callRepository = new CallRepository(validated.data);
                 const result = validated.submission
                     ? await callRepository.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callRepository.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "arbitration": {
                 const callArbitration = new CallArbitration(validated.data);
                 const result = validated.submission
                     ? await callArbitration.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callArbitration.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "contact": {
                 const callContact = new CallContact(validated.data);
                 const result = validated.submission
                     ? await callContact.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callContact.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "treasury": {
                 const callTreasury = new CallTreasury(validated.data);
                 const result = validated.submission
                     ? await callTreasury.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callTreasury.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "reward": {
-                const transformedData = transformRewardData(validated.data);
+                const transformedData = transformRewardInput(validated.data);
                 const callReward = new CallReward(transformedData);
                 const result = validated.submission
                     ? await callReward.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callReward.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "allocation": {
                 const callAllocation = new CallAllocation(validated.data);
                 const result = validated.submission
                     ? await callAllocation.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callAllocation.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "permission": {
                 const callPermission = new CallPermission(validated.data);
                 const result = await callPermission.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "guard": {
                 const validatedData = validated.data;
@@ -560,217 +542,120 @@ async function handleOnchainOperations(args) {
                 }
                 const callGuard = new CallGuard(validatedData);
                 const result = await callGuard.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "personal": {
-                const transformPersonalData = (data) => {
-                    const result = { ...data };
-                    if (data.mark) {
-                        const transformAddress = (addr) => {
-                            if (typeof addr === 'string') {
-                                return { name_or_address: addr, local_mark_first: true };
-                            }
-                            return addr;
-                        };
-                        if (data.mark.op === 'add' && data.mark.data) {
-                            result.mark = {
-                                ...data.mark,
-                                data: data.mark.data.map((item) => ({
-                                    ...item,
-                                    address: transformAddress(item.address)
-                                }))
-                            };
-                        }
-                        else if (data.mark.op === 'remove' && data.mark.data) {
-                            result.mark = {
-                                ...data.mark,
-                                data: data.mark.data.map((item) => ({
-                                    ...item,
-                                    address: transformAddress(item.address)
-                                }))
-                            };
-                        }
-                        else if (data.mark.op === 'clear' && data.mark.address) {
-                            const addr = data.mark.address;
-                            if (Array.isArray(addr) && addr.every((a) => typeof a === 'string')) {
-                                result.mark = {
-                                    ...data.mark,
-                                    address: {
-                                        entities: addr.map((a) => ({ name_or_address: a, local_mark_first: true }))
-                                    }
-                                };
-                            }
-                        }
-                        else if (data.mark.op === 'transfer' && data.mark.to) {
-                            result.mark = {
-                                ...data.mark,
-                                to: transformAddress(data.mark.to)
-                            };
-                        }
-                    }
-                    return result;
-                };
-                const transformedData = transformPersonalData(validated.data);
+                const transformedData = transformPersonalInput(validated.data);
                 const callPersonal = new CallPersonal(transformedData);
                 const result = await callPersonal.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "payment": {
                 const callPayment = new CallPayment(validated.data);
                 const result = await callPayment.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "demand": {
                 const callDemand = new CallDemand(validated.data);
                 const result = validated.submission
                     ? await callDemand.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callDemand.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "order": {
                 const callOrder = new CallOrder(validated.data);
                 const result = validated.submission
                     ? await callOrder.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callOrder.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "gen_passport": {
                 const result = await gen_passport(env, validated.guard, validated.info);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "proof": {
                 const callProof = new CallProof(validated.data);
                 const result = validated.submission
                     ? await callProof.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callProof.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
             case "gen_proof": {
                 const result = await gen_proof(env, validated.proof, validated.server_pubkey, validated.server_signature, validated.proof_type, validated.description, validated.item_count, validated.about_address);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
+                return handleCallResult(result, buildCtx(validated.data));
             }
         }
         throw new Error(`Unknown on-chain operation type: ${validated.operation_type}`);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        return handleCallResult({ error: errorMessage }, validated ? { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined } : undefined);
-    }
-}
-async function handleAccountOperation(args) {
-    let validated;
-    try {
-        validated = strictParse(AccountOperationSchema, args, "account_operation input");
-        const result = await account_operation(validated);
-        const ctx = { operation_type: "account_" + validated.operation_type, data: validated };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: {
-                result: {
-                    status: "success",
-                    data: result,
-                },
-                semantic: buildDataSemantic(result, ctx),
-            },
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const ctx = validated ? { operation_type: "account_" + validated.operation_type, data: validated } : undefined;
-        const classified = classifyError(errorMessage);
-        const errorResult = {
-            status: "error",
-            error: errorMessage,
-        };
-        if (classified.error_code !== undefined)
-            errorResult.error_code = classified.error_code;
-        if (classified.retryable !== undefined)
-            errorResult.retryable = classified.retryable;
-        if (classified.recovery_hint !== undefined)
-            errorResult.recovery_hint = classified.recovery_hint;
-        return {
-            content: [{ type: "text", text: `Error: ${errorMessage}` }],
-            structuredContent: {
-                result: errorResult,
-                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
-            },
-        };
+        return handleCallResult({ error: errorMessage }, validated ? {
+            operation_type: validated.operation_type,
+            data: validated.data,
+        } : undefined);
     }
 }
-async function handleMarkOperation(args) {
-    let validated;
-    try {
-        validated = strictParse(LocalMarkOperationSchema, args, "local_mark_operation input");
-        const result = await local_mark_operation(validated);
-        const ctx = { operation_type: "mark_" + validated.operation_type, data: validated };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: {
-                result: {
-                    status: "success",
-                    data: result,
+function wrapLocalHandler(config) {
+    const { schema, operationFn, parseLabel, buildContext } = config;
+    return async (args) => {
+        let validated;
+        try {
+            validated = strictParse(schema, args, parseLabel);
+            const result = await operationFn(validated);
+            const ctx = buildContext(validated);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                structuredContent: {
+                    result: {
+                        status: "success",
+                        data: result,
+                    },
+                    semantic: buildDataSemantic(result, ctx),
                 },
-                semantic: buildDataSemantic(result, ctx),
-            },
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const ctx = validated ? { operation_type: "mark_" + validated.operation_type, data: validated } : undefined;
-        const classified = classifyError(errorMessage);
-        const errorResult = { status: "error", error: errorMessage };
-        if (classified.error_code !== undefined)
-            errorResult.error_code = classified.error_code;
-        if (classified.retryable !== undefined)
-            errorResult.retryable = classified.retryable;
-        if (classified.recovery_hint !== undefined)
-            errorResult.recovery_hint = classified.recovery_hint;
-        return {
-            content: [{ type: "text", text: `Error: ${errorMessage}` }],
-            structuredContent: {
-                result: errorResult,
-                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
-            },
-        };
-    }
-}
-async function handleInfoOperation(args) {
-    let validated;
-    try {
-        validated = strictParse(LocalInfoOperationSchema, args, "local_info_operation input");
-        const result = await local_info_operation(validated);
-        const ctx = { operation_type: "local_info", data: validated };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: {
-                result: {
-                    status: "success",
-                    data: result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const ctx = validated ? buildContext(validated) : undefined;
+            const classified = classifyError(errorMessage);
+            const errorResult = {
+                status: "error",
+                error: errorMessage,
+            };
+            if (classified.error_code !== undefined)
+                errorResult.error_code = classified.error_code;
+            if (classified.retryable !== undefined)
+                errorResult.retryable = classified.retryable;
+            if (classified.recovery_hint !== undefined)
+                errorResult.recovery_hint = classified.recovery_hint;
+            return {
+                content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                structuredContent: {
+                    result: errorResult,
+                    semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
                 },
-                semantic: buildDataSemantic(result, ctx),
-            },
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const ctx = validated ? { operation_type: "local_info", data: validated } : undefined;
-        const classified = classifyError(errorMessage);
-        const errorResult = { status: "error", error: errorMessage };
-        if (classified.error_code !== undefined)
-            errorResult.error_code = classified.error_code;
-        if (classified.retryable !== undefined)
-            errorResult.retryable = classified.retryable;
-        if (classified.recovery_hint !== undefined)
-            errorResult.recovery_hint = classified.recovery_hint;
-        return {
-            content: [{ type: "text", text: `Error: ${errorMessage}` }],
-            structuredContent: {
-                result: errorResult,
-                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
-            },
-        };
-    }
+            };
+        }
+    };
 }
+const handleAccountOperation = wrapLocalHandler({
+    schema: AccountOperationSchema,
+    operationFn: account_operation,
+    parseLabel: "account_operation input",
+    buildContext: (validated) => ({ operation_type: "account_" + validated.operation_type, data: validated }),
+});
+const handleMarkOperation = wrapLocalHandler({
+    schema: LocalMarkOperationSchema,
+    operationFn: local_mark_operation,
+    parseLabel: "local_mark_operation input",
+    buildContext: (validated) => ({ operation_type: "mark_" + validated.operation_type, data: validated }),
+});
+const handleInfoOperation = wrapLocalHandler({
+    schema: LocalInfoOperationSchema,
+    operationFn: local_info_operation,
+    parseLabel: "local_info_operation input",
+    buildContext: (validated) => ({ operation_type: "local_info", data: validated }),
+});
 async function handleWipOperations(args) {
     const validated = strictParse(WipOperationsSchema, args, "wip_file input");
     let structuredContent;
@@ -995,47 +880,55 @@ async function handleConfigOperation(args) {
             const service = args.service;
             if (!service)
                 throw new Error("'service' param is required for toggle");
-            const validServices = ["confirm_gate", "project_service", "harness", "graph_persist", "semantic_rich"];
-            if (!validServices.includes(service)) {
-                throw new Error(`Unknown service: ${service}. Valid: ${validServices.join(", ")}`);
+            const existing = getServiceInfo(service);
+            if (!existing) {
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
             }
             const newState = toggleService(service);
-            const info = getServiceInfo(service);
-            result = { service, enabled: newState, reminder: info?.reminder };
+            result = { service, enabled: newState, reminder: existing.reminder };
             break;
         }
         case "enable": {
             const service = args.service;
             if (!service)
                 throw new Error("'service' param is required for enable");
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
             setServiceEnabled(service, true);
-            const info = getServiceInfo(service);
-            result = { service, enabled: true, reminder: info?.reminder };
+            result = { service, enabled: true, reminder: existing.reminder };
             break;
         }
         case "disable": {
             const service = args.service;
             if (!service)
                 throw new Error("'service' param is required for disable");
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
             setServiceEnabled(service, false);
-            const info = getServiceInfo(service);
-            result = { service, enabled: false, reminder: info?.reminder };
+            result = { service, enabled: false, reminder: existing.reminder };
             break;
         }
         case "reset": {
             const service = args.service;
             if (!service)
                 throw new Error("'service' param is required for reset");
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
             resetService(service);
-            const info = getServiceInfo(service);
-            result = { service, enabled: info?.enabled, reminder: info?.reminder, reset: true };
+            result = { service, enabled: getServiceInfo(service)?.enabled, reminder: existing.reminder, reset: true };
             break;
         }
         case "info": {
             const service = args.service;
             if (!service)
                 throw new Error("'service' param is required for info");
-            result = getServiceInfo(service);
+            const info = getServiceInfo(service);
+            if (!info)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            result = info;
             break;
         }
         default:
@@ -1046,6 +939,195 @@ async function handleConfigOperation(args) {
         structuredContent: { result },
     };
 }
+function extractTrustMetrics(serviceObj) {
+    const data = serviceObj?.data ?? serviceObj ?? {};
+    const sales = Array.isArray(data.sales) ? data.sales : [];
+    const activeSales = sales.filter((s) => s && !s.suspension);
+    const compensationFund = data.compensation_fund;
+    const compBalance = (() => {
+        if (compensationFund === null || compensationFund === undefined)
+            return undefined;
+        if (typeof compensationFund === "bigint")
+            return compensationFund;
+        if (typeof compensationFund === "number")
+            return BigInt(compensationFund);
+        if (typeof compensationFund === "string") {
+            try {
+                return BigInt(compensationFund);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (typeof compensationFund === "object") {
+            const bal = compensationFund.balance;
+            if (bal === null || bal === undefined)
+                return undefined;
+            try {
+                return BigInt(bal);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    })();
+    return {
+        arbitrationCases: Array.isArray(data.arbitrations) ? data.arbitrations.length : undefined,
+        compensationFundBalance: compBalance,
+        hasMachineBound: typeof data.machine === "string" && data.machine.length > 0,
+        hasBuyGuard: typeof data.buy_guard === "string" && data.buy_guard.length > 0,
+    };
+}
+function buildPuzzleRawData(serviceObj, orderAmount, trustScore, serviceOwner) {
+    const data = serviceObj?.data ?? serviceObj ?? {};
+    const sales = Array.isArray(data.sales) ? data.sales : [];
+    const order_allocators = data.order_allocators
+        ? Array.isArray(data.order_allocators.allocators)
+            ? data.order_allocators
+            : { allocators: data.order_allocators }
+        : undefined;
+    const serviceRaw = {
+        name: data.name ?? serviceObj?.id,
+        bPublished: data.bPublished,
+        bPaused: data.bPaused,
+        price: sales[0]?.price != null ? String(sales[0].price) : "0",
+        priceRaw: sales[0]?.price != null ? BigInt(sales[0].price) : 0n,
+        token_type: sales[0]?.price_type ?? (compensation_fund_token(data) ?? "0x2::wow::WOW"),
+        sales,
+        machine: data.machine ?? undefined,
+        buy_guard: data.buy_guard ?? undefined,
+        customer_required: data.customer_required,
+        arbitrations: data.arbitrations,
+        compensation_fund: data.compensation_fund
+            ? { balance: extractBalance(data.compensation_fund) }
+            : undefined,
+        compensation_lock_duration: typeof data.setting_lock_duration === "number"
+            ? data.setting_lock_duration
+            : undefined,
+        um: data.um ?? undefined,
+        order_allocators: order_allocators ? [order_allocators] : undefined,
+    };
+    return {
+        service: serviceRaw,
+        order_amount: orderAmount,
+        trust_score: trustScore,
+        service_owner: serviceOwner,
+    };
+}
+function compensation_fund_token(data) {
+    if (data?.compensation_fund && typeof data.compensation_fund === "object") {
+        return data.compensation_fund.token_type;
+    }
+    return undefined;
+}
+function extractBalance(b) {
+    if (b === null || b === undefined)
+        return 0n;
+    if (typeof b === "bigint")
+        return b;
+    if (typeof b === "number")
+        return BigInt(b);
+    if (typeof b === "string") {
+        try {
+            return BigInt(b);
+        }
+        catch {
+            return 0n;
+        }
+    }
+    if (typeof b === "object") {
+        const bal = b.balance;
+        if (bal === null || bal === undefined)
+            return 0n;
+        try {
+            return BigInt(bal);
+        }
+        catch {
+            return 0n;
+        }
+    }
+    return 0n;
+}
+async function handleTrustScore(args) {
+    const validated = strictParse(TrustScoreInputSchema, args, "trust_score input");
+    const depth = (validated.depth ?? "evaluate");
+    const queryResult = await query_objects({
+        objects: [validated.service],
+        no_cache: validated.no_cache,
+        network: validated.network,
+    });
+    const objects = queryResult?.objects;
+    if (!objects || !Array.isArray(objects) || objects.length === 0) {
+        throw new Error(`Service object not found for '${validated.service}'. ` +
+            `Verify the ID/name and network, or use query_toolkit with query_type='onchain_objects' to debug.`);
+    }
+    const serviceObj = objects[0];
+    const objType = serviceObj?.data?.object_type ?? serviceObj?.object_type ?? serviceObj?.type;
+    if (objType && typeof objType === "string" && !objType.includes("Service")) {
+        throw new Error(`Object '${validated.service}' is not a Service (type: ${objType}). ` +
+            `trust_score only evaluates Service objects.`);
+    }
+    const metrics = extractTrustMetrics(serviceObj);
+    const trustScore = computeServiceTrustScore(metrics);
+    const sales = Array.isArray(serviceObj?.data?.sales) ? serviceObj.data.sales : [];
+    const activeSale = sales.find((s) => s && !s.suspension) ?? sales[0];
+    const salePriceRaw = activeSale?.price != null ? BigInt(activeSale.price) : 0n;
+    const orderAmount = validated.order_amount != null
+        ? BigInt(validated.order_amount)
+        : salePriceRaw;
+    let riskScore = undefined;
+    let infoPuzzle = undefined;
+    if (depth === "evaluate" || depth === "preorder") {
+        const puzzleRaw = buildPuzzleRawData(serviceObj, orderAmount, { score: trustScore.score, level: trustScore.level }, undefined);
+        infoPuzzle = assembleInfoPuzzle(validated.service, puzzleRaw, depth);
+        riskScore = assessRisk(infoPuzzle);
+    }
+    const result = {
+        service_id: validated.service,
+        service_name: serviceObj?.data?.name ?? serviceObj?.name ?? validated.service,
+        service_basics: {
+            bPublished: serviceObj?.data?.bPublished ?? false,
+            bPaused: serviceObj?.data?.bPaused ?? false,
+            sales_count: sales.filter((s) => s && !s.suspension).length,
+            has_machine: !!serviceObj?.data?.machine,
+            has_buy_guard: !!serviceObj?.data?.buy_guard,
+            has_um_contact: !!serviceObj?.data?.um,
+            arbitrations_count: Array.isArray(serviceObj?.data?.arbitrations)
+                ? serviceObj.data.arbitrations.length
+                : 0,
+        },
+        trust_score: {
+            score: trustScore.score,
+            level: trustScore.level,
+            summary: trustScore.summary,
+            warnings: trustScore.warnings,
+            breakdown: trustScore.breakdown,
+        },
+        order_amount: orderAmount.toString(),
+        depth,
+        ...(riskScore ? {
+            risk_score: {
+                total: riskScore.total,
+                level: riskScore.level,
+                red_flags: riskScore.red_flags,
+                advice: riskScore.advice,
+                dimensions: riskScore.dimensions,
+            },
+        } : {}),
+        ...(infoPuzzle ? {
+            info_puzzle: {
+                completeness: infoPuzzle.completeness,
+                gaps: infoPuzzle.gaps,
+                assembled_at: infoPuzzle.assembled_at,
+            },
+        } : {}),
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}
 function normalizeAccountOrMark(input) {
     if (typeof input === 'string') {
         return { name_or_address: input, local_mark_first: true };
@@ -1340,7 +1422,7 @@ async function main() {
     console.error(`Phase 2 active services: ${activeServices.join(", ") || "none"}`);
     reg("onchain_operations", {
         title: "⛓️ On-chain Operations",
-        description: "On-chain operations for WoWok object: service (marketplace listings), machine (workflow templates), progress (order tracking), repository (on-chain database), arbitration (dispute resolution), contact (IM management), treasury (team funds), reward (incentive pools), allocation (auto-distribution), permission (access control), guard (programmable trust rules), personal (public profile), payment (direct coin transfers), demand (service requests), order (order management), gen_passport (verified credentials), proof (on-chain proof objects), gen_proof (generate proof shortcut).",
+        description: "On-chain operations for WoWok object: service (marketplace listings), machine (workflow templates), progress (order tracking), repository (on-chain database), arbitration (dispute resolution), contact (IM management), treasury (team funds), reward (incentive pools), allocation (auto-distribution), permission (access control), guard (programmable trust rules), personal (public profile), payment (direct coin transfers), demand (service requests), order (order management), gen_passport (verified credentials), proof (on-chain proof objects), gen_proof (generate proof shortcut).\n\n💡 Schema hint: Use schema_query with action='get' and name='onchain_operations' to retrieve the complete parameter schema. For individual operation schemas (e.g., 'onchain_operations_permission'), use schema_query with action='list_operations' to see all available operation schemas.",
         inputSchema: OnchainOperationsSchema,
         outputSchema: CallOutputSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
@@ -1348,7 +1430,7 @@ async function main() {
     }, handleOnchainOperations);
     reg("account_operation", {
         title: "🔒 LOCAL ONLY: Account - Wallet Management",
-        description: "🔒 100% LOCAL, NEVER ON-CHAIN 🔒 Manage WoWok accounts locally on device: generate, suspend, resume, faucet-test, operate assets, sign data, etc.",
+        description: "🔒 100% LOCAL, NEVER ON-CHAIN 🔒 Manage WoWok accounts locally on device: generate, suspend, resume, faucet-test, operate assets, sign data, etc.\n\n💡 Schema hint: Use schema_query with action='get' and name='account_operation' to retrieve the exact parameter schema before calling.",
         inputSchema: AccountOperationSchema,
         outputSchema: AccountOperationOutputWrappedSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
@@ -1356,7 +1438,7 @@ async function main() {
     }, handleAccountOperation, statusErrorShape);
     reg("local_mark_operation", {
         title: "🔒 LOCAL ONLY: LocalMark - Address Book Management",
-        description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage ID names and tags stored ONLY on your local device for easy identification of user address or object IDs by name.",
+        description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage ID names and tags stored ONLY on your local device for easy identification of user address or object IDs by name.\n\n💡 Schema hint: Use schema_query with action='get' and name='local_mark_operation' to retrieve the exact parameter schema before calling.",
         inputSchema: LocalMarkOperationSchema,
         outputSchema: LocalMarkOperationOutputWrappedSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
@@ -1364,7 +1446,7 @@ async function main() {
     }, handleMarkOperation, statusErrorShape);
     reg("local_info_operation", {
         title: "🔒 LOCAL ONLY: LocalInfo - Private Data Management",
-        description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage sensitive personal information stored ONLY on your device: delivery addresses, phone numbers, contacts.",
+        description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage sensitive personal information stored ONLY on your device: delivery addresses, phone numbers, contacts.\n\n💡 Schema hint: Use schema_query with action='get' and name='local_info_operation' to retrieve the exact parameter schema before calling.",
         inputSchema: LocalInfoOperationSchema,
         outputSchema: LocalInfoOperationOutputWrappedSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
@@ -1372,7 +1454,7 @@ async function main() {
     }, handleInfoOperation, statusErrorShape);
     reg("wip_file", {
         title: "🤝 Witness Immutable Promise File Operations",
-        description: "generate (create WIP files from markdown and images), verify (integrity check), sign (add signatures), or wip2html (convert to HTML).",
+        description: "generate (create WIP files from markdown and images), verify (integrity check), sign (add signatures), or wip2html (convert to HTML).\n\n💡 Schema hint: Use schema_query with action='get' and name='wip_file' to retrieve the exact parameter schema before calling.",
         inputSchema: WipOperationsSchema,
         outputSchema: z.object({
             result: WipOperationOutputSchema,
@@ -1382,7 +1464,7 @@ async function main() {
     }, handleWipOperations);
     reg("messenger_operation", {
         title: "💬 Messenger Operations",
-        description: "WoWok encrypted messenger operations: watch conversations (with unread filtering, preview messages), send message, send file, watch messages (with viewed status filtering), extract zip messages, generate WTS, verify WTS, sign WTS, WTS to HTML, proof message on-chain, manage blacklist, friendslist, guardlist, settings, mark messages as viewed, mark conversation as viewed, and pull messages from server.",
+        description: "WoWok encrypted messenger operations: watch conversations (with unread filtering, preview messages), send message, send file, watch messages (with viewed status filtering), extract zip messages, generate WTS, verify WTS, sign WTS, WTS to HTML, proof message on-chain, manage blacklist, friendslist, guardlist, settings, mark messages as viewed, mark conversation as viewed, and pull messages from server.\n\n💡 Schema hint: Use schema_query with action='get' and name='messenger_operation' to retrieve the exact parameter schema before calling.",
         inputSchema: MessengerOperationInputSchema,
         outputSchema: MessengerOperationOutputSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
@@ -1390,7 +1472,7 @@ async function main() {
     }, handleMessengerOperation, operationErrorShape, 30000);
     reg("guard2file", {
         title: "📄 Guard to File - Export Guard Definition",
-        description: "Export a Guard object's definition from the blockchain to a local JSON or Markdown file for editing and creating new Guard objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
+        description: "Export a Guard object's definition from the blockchain to a local JSON or Markdown file for editing and creating new Guard objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.\n\n💡 Schema hint: Use schema_query with action='get' and name='guard2file' to retrieve the exact parameter schema before calling.",
         inputSchema: Guard2File_InputSchema,
         outputSchema: Guard2File_OutputWrappedSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
@@ -1398,7 +1480,7 @@ async function main() {
     }, handleGuard2File, strictStatusErrorShape);
     reg("machineNode2file", {
         title: "⚙️ Machine Node to File - Export Machine Node Definition",
-        description: "Export a Machine object's node definition from the blockchain to a local JSON or Markdown file for editing and creating new Machine objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
+        description: "Export a Machine object's node definition from the blockchain to a local JSON or Markdown file for editing and creating new Machine objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.\n\n💡 Schema hint: Use schema_query with action='get' and name='machineNode2file' to retrieve the exact parameter schema before calling.",
         inputSchema: MachineNode2File_InputSchema,
         outputSchema: MachineNode2File_OutputWrappedSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
@@ -1418,7 +1500,8 @@ async function main() {
             + "7. onchain_personal_profile — Query any user's PUBLIC on-chain profile: social links, reputation (likes/dislikes), personal info records, voting history, referrer.\n"
             + "8. onchain_objects — Batch query on-chain WOWOK objects by ID or name: supports Service, Machine, Order, Treasury, Reward, Arb, Personal, Contact, and more.\n"
             + "9. onchain_received — Query objects (Payments, Tokens, NFTs) received by a specific object. Supports pagination and type filter.\n\n"
-            + "For dynamic table data queries (pagination, table items), use the 'onchain_table_data' tool.",
+            + "For dynamic table data queries (pagination, table items), use the 'onchain_table_data' tool.\n\n"
+            + "💡 Schema hint: Use schema_query with action='get' and name='query_toolkit' to retrieve the exact parameter schema with all query types and field definitions.",
         inputSchema: WatchQueryOperationsSchema,
         outputSchema: z.object({
             result: z.unknown().describe("Query result — type depends on query_type. Local queries return arrays (MarkData[], AccountData[], InfoData[], TokenTypeInfo[]). account_balance returns { address, balance? | coin? }. Onchain queries return typed objects or undefined. onchain_received returns ReceivedBalance | ReceivedNormal[]."),
@@ -1441,7 +1524,8 @@ async function main() {
             + "9. onchain_table_item_machine_node — Query a workflow node definition from a Machine object's node table (Parent: Machine). Key: node name (string). Returns node configuration: pairs, forwards, guards, thresholds.\n"
             + "10. onchain_table_item_progress_history — Query a progress step record from a Progress object's history table (Parent: Progress). Key: sequence number (u64). Returns step details: node, next_node, session state, time.\n"
             + "11. onchain_table_item_address_mark — Query a PUBLIC on-chain name/tag mark from an AddressMark object's table (Parent: AddressMark). Key: address. Returns public labels: entity, name, tags[]. Unlike local marks, these are published on-chain.\n"
-            + "12. onchain_table_item_generic — Query a generic table item from ANY object's dynamic fields (Parent: any object). Supports arbitrary key types (address, u64, string, object ID, etc.). Use for custom objects and general-purpose table lookups. Returns: ObjectBase | undefined.",
+            + "12. onchain_table_item_generic — Query a generic table item from ANY object's dynamic fields (Parent: any object). Supports arbitrary key types (address, u64, string, object ID, etc.). Use for custom objects and general-purpose table lookups. Returns: ObjectBase | undefined.\n\n"
+            + "💡 Schema hint: Use schema_query with action='get' and name='onchain_table_data' to retrieve the exact parameter schema with all table item types and field definitions.",
         inputSchema: OnchainTableDataSchema,
         outputSchema: OnchainTableDataResultSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
@@ -1449,7 +1533,7 @@ async function main() {
     }, handleOnchainTableData);
     reg("onchain_events", {
         title: "📅 Watch WoWok On-chain Events",
-        description: "Watch on-chain WoWok events by type. Supports arbitration events, new order events, progress events, demand presentation events, demand feedback events, and new entity registration events. Use pagination cursor for fetching large result sets.",
+        description: "Watch on-chain WoWok events by type. Supports arbitration events, new order events, progress events, demand presentation events, demand feedback events, and new entity registration events. Use pagination cursor for fetching large result sets.\n\n💡 Schema hint: Use schema_query with action='get' and name='onchain_events' to retrieve the exact parameter schema with all event types and field definitions.",
         inputSchema: OnchainEventsInputSchema,
         outputSchema: OnchainEventsResultSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
@@ -1474,19 +1558,8 @@ async function main() {
             "  'get_output' - Fetch the output JSON Schema of a tool by name (e.g. 'onchain_operations'). Use with the 'name' param. Use this to understand a tool's return value structure.\n" +
             "  'search' - Find schemas by keyword, matching name/title/description. Use with the 'query' param.\n" +
             "  'list_operations' - Show only on-chain operation schemas (prefixed 'onchain_operations_'). Narrower than 'list'.",
-        inputSchema: z.object({
-            action: z.enum(["list", "get", "get_output", "search", "list_operations"])
-                .describe("Action to perform: 'list' to see all available schemas, 'get' to retrieve a specific input schema, 'get_output' to retrieve a tool's output schema, 'search' to find schemas by keyword, 'list_operations' to list all on-chain operations"),
-            name: z.string().optional().describe("Schema/tool name for 'get'/'get_output' action (e.g., 'onchain_operations', 'account_operation', 'onchain_operations_permission')"),
-            query: z.string().optional().describe("Search query for 'search' action"),
-        }),
-        outputSchema: z.object({
-            success: z.boolean().describe("Whether the request was successful"),
-            action: z.string().describe("The action that was performed"),
-            data: z.any().describe("Response data - JSON Schema object for 'get'/'get_output', array of schema info for 'list'/'search'/'list_operations'"),
-            message: z.string().describe("Human-readable message describing the result"),
-            suggestions: z.array(z.string()).optional().describe("Suggested next steps or alternatives"),
-        }),
+        inputSchema: SchemaQueryInputSchema,
+        outputSchema: SchemaQueryOutputSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("schema", ["schema", "json-schema", "types", "structure", "validation", "reference"]),
     }, async (args) => {
@@ -1622,20 +1695,10 @@ async function main() {
             "  • load_graph — Load the graph from file (restore after restart).\n\n" +
             "NOTE: The graph is in-memory by default. Use save_graph/load_graph for cross-session persistence " +
             "(or toggle graph_persist via config_operation for auto-save). " +
-            "list_projects/shareable always query local_mark (persistent).",
-        inputSchema: z.object({
-            action: z.enum([
-                "list_projects", "list_objects", "shareable",
-                "dependencies", "referenced_by", "pre_publish_check",
-                "cross_project_refs", "graph_stats",
-                "save_graph", "load_graph",
-            ]).describe("Query/action to perform"),
-            project: z.string().optional().describe("Project prefix (for list_objects)"),
-            object: z.string().optional().describe("Object name or address (for dependencies / referenced_by / pre_publish_check)"),
-        }),
-        outputSchema: z.object({
-            result: z.any().describe("Query result — shape depends on action"),
-        }),
+            "list_projects/shareable always query local_mark (persistent).\n\n" +
+            "💡 Schema hint: Use schema_query with action='get' and name='project_operation' to retrieve the exact parameter schema with all actions and field definitions.",
+        inputSchema: ProjectOperationInputSchema,
+        outputSchema: ProjectOperationOutputSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("project", ["project", "namespace", "graph", "dag", "dependency", "reference", "organization"]),
     }, handleProjectOperation);
@@ -1656,19 +1719,43 @@ async function main() {
             "  • project_service — Project Namespace + Dependency Graph (default ON)\n" +
             "  • harness — L4 Verify/Recover Loop (default OFF)\n" +
             "  • graph_persist — Graph Persistence to File (default OFF)\n" +
-            "  • semantic_rich — Semantic Layer Enrichment Reminder (default ON)\n\n" +
+            "  • semantic_rich — Semantic Layer Enrichment Reminder (default ON)\n" +
+            "  • experience_layer — Real-time Experience Layer (Phase 2 Topic 2, default ON)\n" +
+            "  • customer_intelligence — Buyer Intelligence / Risk & Preference Alerts (Phase 3 C-3, default ON)\n" +
+            "  • order_monitor — In-progress Order Monitoring (Phase 3 C-3.2, default OFF)\n" +
+            "  • industry_evolution — Industry Specialization Evolution Flywheel (Phase 4, default ON)\n\n" +
             "NOTE: Toggles persist for the MCP process lifetime. Set WOWOK_RUNTIME_CONFIG_PERSIST=1 " +
-            "to persist across sessions to ~/.wowok/runtime-config.json.",
-        inputSchema: z.object({
-            action: z.enum(["list", "toggle", "enable", "disable", "reset", "info"]).describe("Config action to perform"),
-            service: z.string().optional().describe("Service name (required for toggle/enable/disable/reset/info)"),
-        }),
-        outputSchema: z.object({
-            result: z.any().describe("Config result — shape depends on action"),
-        }),
+            "to persist across sessions to ~/.wowok/runtime-config.json.\n\n" +
+            "💡 Schema hint: Use schema_query with action='get' and name='config_operation' to retrieve the exact parameter schema with all actions and field definitions.",
+        inputSchema: ConfigOperationInputSchema,
+        outputSchema: ConfigOperationOutputSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("config", ["config", "toggle", "service", "runtime", "switch", "enable", "disable"]),
     }, handleConfigOperation);
+    reg("trust_score", {
+        title: "🛡️ Trust Score - Service Risk & Trust Assessment",
+        description: "Proactively query the trust score and risk assessment of a Service object. " +
+            "This is the standalone query form of the trust_score field that is otherwise only " +
+            "passively injected into onchain_operations semantic output.\n\n" +
+            "Returns:\n" +
+            "  • trust_score (0-100, 5 dimensions: arbitration/reviews/fulfillment/fund_safety/transparency)\n" +
+            "  • risk_score (4 dimensions: workflow/fund/trust/behavior, 100-point) when depth >= 'evaluate'\n" +
+            "  • info_puzzle completeness + gaps summary\n" +
+            "  • service_basics snapshot (published/paused/sales/guards/arbitrations)\n\n" +
+            "Use this tool when the user asks 'is this service trustworthy?', 'should I buy from this merchant?', " +
+            "'what's the risk of ordering this service?', or any explicit trust/risk inquiry about a Service.\n\n" +
+            "Parameters:\n" +
+            "  • service (required) — Service object ID or local_mark name.\n" +
+            "  • order_amount (optional) — Order amount in smallest token unit (e.g. 2000000000 for 2 WOW). " +
+            "Defaults to the service's first active sale price.\n" +
+            "  • depth (optional, default 'evaluate') — 'browse' (trust score only), 'evaluate' (+ risk assessment), " +
+            "'preorder' (most thorough, includes market context dimension).\n\n" +
+            "💡 Schema hint: Use schema_query with action='get' and name='trust_score' to retrieve the exact parameter schema.",
+        inputSchema: TrustScoreInputSchema,
+        outputSchema: TrustScoreOutputSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("trust", ["trust", "score", "risk", "service", "merchant", "reputation", "safety", "evaluate"]),
+    }, handleTrustScore);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     process.on("SIGINT", async () => {