@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/index.js

@@ -1,92 +1,18 @@
 #!/usr/bin/env node
-import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 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, 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";
-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, 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())
-        return base;
-    try {
-        const harness = getHarness();
-        const expected = harness.expect(operation, intent, base.operation_type, base.data);
-        return {
-            ...base,
-            harness,
-            expected,
-            operation_id: `${base.operation_type}_${Date.now()}`,
-        };
-    }
-    catch {
-        return base;
-    }
-}
-function buildPendingConfirmation(operation_type, data, env) {
-    const gate = confirmGate(operation_type, data, env, env?.user_intent_phrases);
-    if (gate.pass)
-        return { content: [], structuredContent: null };
-    const preview = gate.preview;
-    const rendered = renderPreview(preview);
-    const output = {
-        message: rendered,
-        result: {
-            type: "pending_confirmation",
-            preview,
-            rule_id: gate.rule_id,
-        },
-        semantic: {
-            intent: `${operation_type}_awaiting_confirmation`,
-            status: "pending_input",
-            summary: `Operation blocked by ConfirmGate (${gate.level}). Review the preview and re-call with env.confirmed=true to proceed.`,
-            next_actions: [
-                {
-                    action: "confirm: re-call the SAME operation with env.confirmed=true",
-                    reason: `ConfirmGate rule '${gate.rule_id}' matched. The operation was NOT executed.`,
-                    tool: "onchain_operations",
-                    priority: "required",
-                },
-            ],
-            warnings: preview.warnings ?? [],
-        },
-    };
-    return {
-        content: [{ type: "text", text: rendered }],
-        structuredContent: output,
-    };
-}
-function buildConstraintError(operation_type, violations) {
-    const errors = violations.filter((v) => v.severity === "error");
-    const errorList = errors.map((v) => `  • [${v.field}] ${v.message}`).join("\n");
-    const message = `Pre-call constraint violations for '${operation_type}':\n${errorList}\n\nFix the listed field(s) and retry.`;
-    const output = {
-        message,
-        result: {
-            type: "error",
-            error: message,
-            error_code: "invalid_parameter",
-            retryable: false,
-            recovery_hint: "Review the constraint violations above and correct the corresponding fields.",
-        },
-    };
-    return {
-        content: [{ type: "text", text: message }],
-        structuredContent: output,
-    };
+import { OnchainOperationsSchema, WipOperationsSchema, WatchQueryOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, ProtocolInfoQuerySchema, CallOutputSchema, MessengerOperationInputSchema, MessengerOperationOutputSchema, createServerConfig, createCapabilitiesConfig, } from "./schema/index.js";
+import { areSchemasAvailable, getSchemaIndex, } from "./schema-query/index.js";
+import { isProjectServiceEnabled, observe as projectObserve, } from "./project/index.js";
+import { registerSuccessHook } from "./schema/call/handler.js";
+import { listServices } from "./config/index.js";
+import { setTelemetryEnabled } from "./telemetry/index.js";
+import { registerAllTools } from "./tools/index.js";
+if (process.env.WOWOK_TELEMETRY === "false" || process.env.WOWOK_TELEMETRY === "0") {
+    setTelemetryEnabled(false);
 }
-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.
 
 ## CRITICAL: Schema Discovery Rule
@@ -195,1211 +121,7 @@ Token amounts are HIGHLY SENSITIVE. Always:
 - machineNode2file
 `;
 const server = new McpServer(createServerConfig(packageJson, SERVER_DESCRIPTION), createCapabilitiesConfig());
-import { withTelemetry, setTelemetryEnabled } from "./telemetry/index.js";
-if (process.env.WOWOK_TELEMETRY === "false" || process.env.WOWOK_TELEMETRY === "0") {
-    setTelemetryEnabled(false);
-}
-function buildClassifiedErrorResult(base, error, classified) {
-    const result = { ...base, error };
-    if (classified.error_code !== undefined)
-        result.error_code = classified.error_code;
-    if (classified.retryable !== undefined)
-        result.retryable = classified.retryable;
-    if (classified.recovery_hint !== undefined)
-        result.recovery_hint = classified.recovery_hint;
-    return result;
-}
-const statusErrorShape = (error, classified, ctx) => ({
-    result: buildClassifiedErrorResult({ status: "error" }, error, classified),
-    semantic: buildDataSemantic(undefined, ctx, true, error),
-});
-const operationErrorShape = (error, classified, ctx) => ({
-    result: buildClassifiedErrorResult({ operation: "error" }, error, classified),
-    semantic: buildDataSemantic(undefined, ctx, true, error),
-});
-const strictStatusErrorShape = (error, _classified, _ctx) => ({
-    result: { status: "error", error },
-});
-function reg(name, config, handler, errorShapeBuilder, customTimeoutMs) {
-    const timeoutMs = customTimeoutMs ?? 60000;
-    const wrappedHandler = wrapHandlerWithErrorShape(handler, timeoutMs, name, errorShapeBuilder);
-    server.registerTool(name, config, withTelemetry(name, wrappedHandler));
-}
-function withTimeout(promise, timeoutMs = 30000, operationName = "operation") {
-    let timer;
-    return Promise.race([
-        promise.finally(() => {
-            if (timer)
-                clearTimeout(timer);
-        }),
-        new Promise((_, reject) => {
-            timer = setTimeout(() => {
-                let hint = "";
-                if (operationName.includes("messenger")) {
-                    hint = " This is a messenger network operation. Possible causes: " +
-                        "(1) messenger server (https://messenger.wowok.net) unreachable, " +
-                        "(2) no messenger-enabled account configured (use account_operation to set messenger name), " +
-                        "(3) network connectivity issue. " +
-                        "Ensure you have a messenger-enabled account and the server is reachable.";
-                }
-                reject(new Error(`Operation '${operationName}' timed out after ${timeoutMs}ms.${hint}`));
-            }, timeoutMs);
-        }),
-    ]);
-}
-function wrapHandlerWithErrorShape(handler, timeoutMs, toolName, errorShapeBuilder) {
-    return async (args) => {
-        try {
-            return await withTimeout(handler(args), timeoutMs, toolName);
-        }
-        catch (error) {
-            if (errorShapeBuilder) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                const classified = classifyError(errorMessage);
-                const ctx = { operation_type: toolName, data: args };
-                const structuredContent = errorShapeBuilder(errorMessage, classified, ctx);
-                return {
-                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    structuredContent,
-                };
-            }
-            throw error;
-        }
-    };
-}
-async function handleOnchainTableData(args) {
-    const validated = strictParse(OnchainTableDataSchema, args, "onchain_table_data input");
-    let result;
-    switch (validated.query_type) {
-        case "onchain_table": {
-            const queryResult = await query_table({ parent: validated.parent, cursor: validated.cursor, limit: validated.limit, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_repository_data": {
-            const queryResult = await queryTableItem_RepositoryData({ parent: validated.parent, name: validated.name, entity: validated.entity, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_repository_data", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_permission_perm": {
-            const queryResult = await queryTableItem_PermissionPerm({ parent: validated.parent, address: validated.address, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_permission_perm", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_reward_record": {
-            const queryResult = await queryTableItem_RewardRecord({ parent: validated.parent, address: validated.address, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_reward_record", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_demand_presenter": {
-            const queryResult = await queryTableItem_DemandPresenter({ parent: validated.parent, address: validated.address, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_demand_presenter", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_treasury_history": {
-            const queryResult = await queryTableItem_TreasuryHistory({ parent: validated.parent, address: validated.address, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_treasury_history", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_machine_node": {
-            const queryResult = await queryTableItem_MachineNode({ parent: validated.parent, key: validated.key, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_machine_node", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_progress_history": {
-            const queryResult = await queryTableItem_ProgressHistory({ parent: validated.parent, u64: validated.u64, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_progress_history", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_address_mark": {
-            const queryResult = await queryTableItem_AddressMark({ parent: validated.parent, address: validated.address, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_address_mark", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_entity_registrar": {
-            const queryResult = await queryTableItem_EntityRegistrar({ address: validated.address, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_entity_registrar", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_entity_linker": {
-            const queryResult = await queryTableItem_EntityLinker({ address: validated.address, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_table_item_entity_linker", result: queryResult };
-            break;
-        }
-        case "onchain_table_item_generic": {
-            const queryResult = await query_tableItem({
-                parent: validated.parent,
-                key: { type: validated.key_type, value: validated.key_value },
-                no_cache: validated.no_cache,
-                network: validated.network
-            });
-            result = { query_type: "onchain_table_item_generic", result: queryResult };
-            break;
-        }
-        default:
-            throw new Error(`Unknown table query type. Valid query_types are: "onchain_table", "onchain_table_item_repository_data", "onchain_table_item_permission_perm", "onchain_table_item_reward_record", "onchain_table_item_demand_presenter", "onchain_table_item_treasury_history", "onchain_table_item_machine_node", "onchain_table_item_progress_history", "onchain_table_item_address_mark", "onchain_table_item_entity_registrar", "onchain_table_item_entity_linker", "onchain_table_item_generic"`);
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ result }) }],
-        structuredContent: {
-            result,
-            semantic: buildDataSemantic(result, {
-                operation_type: "onchain_table_data",
-                data: validated,
-            }),
-        },
-    };
-}
-async function handleOnchainOperations(args) {
-    let validated;
-    let constraintWarnings = [];
-    try {
-        if (typeof args === 'object' && args !== null && args.description && !args.operation_type) {
-            const hasWrappedParams = typeof args.description === 'string' &&
-                (args.description.includes('operation_type') || args.description.includes('data'));
-            if (hasWrappedParams) {
-                throw new Error("Invalid parameter structure. Parameters should NOT be wrapped in 'description' field.\n" +
-                    "Correct format: { operation_type: '...', data: {...} }\n" +
-                    "Incorrect format: { description: '{ operation_type: ... }' }");
-            }
-        }
-        validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
-        const env = getEnvConfig(validated.env);
-        const gateResult = buildPendingConfirmation(validated.operation_type, validated.data, env);
-        if (gateResult.structuredContent) {
-            return gateResult;
-        }
-        const constraintViolations = validateOperation(validated.operation_type, validated.data);
-        if (hasBlockingViolations(constraintViolations)) {
-            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({
-                operation_type: validated.operation_type,
-                data: validated.data,
-                projectPrefix: projectEnvPrefix,
-            });
-            validated.data = pn.data;
-        }
-        if (env && typeof env === "object") {
-            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": {
-                const callService = new CallService(validated.data);
-                const result = validated.submission
-                    ? await callService.call_with_submission(env, await transformSubmission(validated.submission))
-                    : 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(buildCtx(data), "service", intent));
-            }
-            case "machine": {
-                if (validated.data.node && typeof validated.data.node === 'object' && 'json_or_markdown_file' in validated.data.node) {
-                    const filePathStr = validated.data.node.json_or_markdown_file;
-                    let fileContent;
-                    try {
-                        const filePath = resolve(filePathStr);
-                        fileContent = readFileSync(filePath, 'utf-8');
-                    }
-                    catch (e) {
-                        throw new Error(`Failed to read file '${filePathStr}': ${e.message}`);
-                    }
-                    const parseResult = parseMachineNodesFromText(fileContent);
-                    if (!parseResult.success) {
-                        const errorMessages = formatMachineNodeErrors(parseResult.errors);
-                        throw new Error(`Machine node validation failed for file '${filePathStr}':\n\n${errorMessages}`);
-                    }
-                    if (!parseResult.data) {
-                        throw new Error(`No nodes found in file '${filePathStr}'`);
-                    }
-                    validated.data.node = {
-                        op: "set",
-                        nodes: parseResult.data,
-                        bReplace: true
-                    };
-                }
-                const callMachine = new CallMachine(validated.data);
-                const result = validated.submission
-                    ? await callMachine.call_with_submission(env, await transformSubmission(validated.submission))
-                    : await callMachine.call(env);
-                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, 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, 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, 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, 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, buildCtx(validated.data));
-            }
-            case "reward": {
-                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, 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, buildCtx(validated.data));
-            }
-            case "permission": {
-                const callPermission = new CallPermission(validated.data);
-                const result = await callPermission.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
-            }
-            case "guard": {
-                const validatedData = validated.data;
-                if (validatedData.root?.type === "file") {
-                    const filePath = resolve(validatedData.root.file_path);
-                    let fileContent;
-                    try {
-                        fileContent = readFileSync(filePath, 'utf-8');
-                    }
-                    catch (e) {
-                        throw new Error(`Failed to read Guard definition file '${validatedData.root.file_path}': ${e.message}`);
-                    }
-                    const parseResult = parseGuardFile(fileContent, validatedData.root.format);
-                    if (!parseResult.success) {
-                        const errorMessages = formatGuardParseErrors(parseResult.errors);
-                        throw new Error(`Guard validation failed for file '${validatedData.root.file_path}':\n\n${errorMessages}`);
-                    }
-                    const fileData = parseResult.data;
-                    validatedData.root = { type: "node", node: fileData.root };
-                    if (fileData.table !== undefined && validatedData.table === undefined) {
-                        validatedData.table = fileData.table;
-                    }
-                    if (fileData.description !== undefined && validatedData.description === undefined) {
-                        validatedData.description = fileData.description;
-                    }
-                    if (fileData.rely !== undefined && validatedData.rely === undefined) {
-                        validatedData.rely = fileData.rely;
-                    }
-                    if (fileData.namedNew !== undefined && validatedData.namedNew === undefined) {
-                        validatedData.namedNew = fileData.namedNew;
-                    }
-                }
-                if (validatedData.root && typeof validatedData.root === 'object') {
-                    const rootObj = validatedData.root;
-                    if (rootObj.type === 'node' && rootObj.node) {
-                        validatedData.root = rootObj.node;
-                    }
-                }
-                if (!validatedData.table || validatedData.table.length === 0) {
-                    throw new Error("Guard 'table' field is required and cannot be empty");
-                }
-                if (!validatedData.root) {
-                    throw new Error("Guard 'root' field is required");
-                }
-                const callGuard = new CallGuard(validatedData);
-                const result = await callGuard.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
-            }
-            case "personal": {
-                const transformedData = transformPersonalInput(validated.data);
-                const callPersonal = new CallPersonal(transformedData);
-                const result = await callPersonal.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
-            }
-            case "payment": {
-                const callPayment = new CallPayment(validated.data);
-                const result = await callPayment.call(env);
-                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, 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, buildCtx(validated.data));
-            }
-            case "gen_passport": {
-                const result = await gen_passport(env, validated.guard, validated.info);
-                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, 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, 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,
-        } : undefined);
-    }
-}
-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),
-                },
-            };
-        }
-        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),
-                },
-            };
-        }
-    };
-}
-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;
-    switch (validated.type) {
-        case "generate": {
-            const result = await generate_wip(validated.options, validated.outputPath);
-            structuredContent = { result: { type: "generate", filePath: result } };
-            break;
-        }
-        case "verify": {
-            const result = await verify_wip(validated.wipFilePath, validated.hash_equal, validated.requireSignature);
-            structuredContent = { result: { type: "verify", ...result } };
-            break;
-        }
-        case "sign": {
-            const result = await sign_wip(validated.wipFilePath, validated.account, validated.outputPath);
-            structuredContent = { result: { type: "sign", filePath: result } };
-            break;
-        }
-        case "wip2html": {
-            const result = await wip2html(validated.wipPath, validated.options);
-            let output = { type: "wip2html" };
-            if (typeof result === "string") {
-                output.html = result;
-            }
-            else if (Array.isArray(result)) {
-                output.files = result;
-            }
-            else {
-                output.html = String(result);
-            }
-            structuredContent = { result: output };
-            break;
-        }
-        default:
-            throw new Error("Unknown WIP operation type");
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
-        structuredContent,
-    };
-}
-async function handleWatchQueryOperations(args) {
-    const validated = strictParse(WatchQueryOperationsSchema, args, "watch_and_query input");
-    let result;
-    switch (validated.query_type) {
-        case "local_mark_list": {
-            const queryResult = await query_local_mark_list(validated.filter || {});
-            result = { query_type: "local_mark_list", result: queryResult };
-            break;
-        }
-        case "account_list": {
-            const queryResult = await query_account_list(validated.filter);
-            result = { query_type: "account_list", result: queryResult };
-            break;
-        }
-        case "local_info_list": {
-            const queryResult = await query_local_info_list(validated.filter);
-            result = { query_type: "local_info_list", result: queryResult };
-            break;
-        }
-        case "token_list": {
-            const queryResult = await query_local_token_list(validated.filter || {});
-            result = { query_type: "token_list", result: queryResult };
-            break;
-        }
-        case "account_balance": {
-            const queryResult = await query_account({ name_or_address: validated.name_or_address, token_type: validated.token_type, balance: validated.balance, coin: validated.coin, network: validated.network });
-            result = { query_type: "account_balance", result: queryResult };
-            break;
-        }
-        case "local_names": {
-            const queryResult = await GetLocalNamesByAddresses(validated.addresses);
-            result = { query_type: "local_names", result: queryResult };
-            break;
-        }
-        case "onchain_personal_profile": {
-            const queryResult = await query_personal({ account: validated.account, no_cache: validated.no_cache, network: validated.network });
-            result = { query_type: "onchain_personal_profile", result: queryResult };
-            break;
-        }
-        case "onchain_objects": {
-            const queryResult = await query_objects({ objects: validated.objects, no_cache: validated.no_cache, network: validated.network });
-            if (queryResult && queryResult.objects && Array.isArray(queryResult.objects)) {
-                queryResult.objects = queryResult.objects.map((obj) => {
-                    if (obj && obj.data && obj.data.type === "Guard" && obj.data.root) {
-                        try {
-                            const nodeComments = generateNodeComments(obj.data.root);
-                            return {
-                                ...obj,
-                                _guard_node_comments: nodeComments
-                            };
-                        }
-                        catch (e) {
-                            return obj;
-                        }
-                    }
-                    return obj;
-                });
-            }
-            result = { query_type: "onchain_objects", result: queryResult };
-            break;
-        }
-        case "onchain_received": {
-            const queryResult = await query_received({
-                name_or_address: normalizeAccountOrMark(validated.name_or_address),
-                type: validated.type,
-                cursor: validated.cursor,
-                limit: validated.limit,
-                no_cache: validated.no_cache,
-                network: validated.network
-            });
-            result = { query_type: "onchain_received", result: queryResult };
-            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". For table queries, use the "onchain_table_data" tool.`);
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ result }) }],
-        structuredContent: {
-            result,
-            semantic: buildDataSemantic(result, {
-                operation_type: "query_toolkit",
-                data: validated,
-            }),
-        },
-    };
-}
-async function handleWowokInfo(args) {
-    const validated = strictParse(ProtocolInfoQuerySchema, args, "wowok_buildin_info input");
-    const queryResult = await queryProtocolInfo(validated);
-    return {
-        content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
-        structuredContent: { result: queryResult },
-    };
-}
-async function handleOnchainEvents(args) {
-    const validated = strictParse(OnchainEventsInputSchema, args, "onchain_events input");
-    const queryResult = await query_events({
-        type: validated.type,
-        cursor: validated.cursor ? {
-            eventSeq: String(validated.cursor.eventSeq),
-            txDigest: validated.cursor.txDigest
-        } : null,
-        limit: validated.limit ?? null,
-        order: validated.order ?? null,
-        no_cache: validated.no_cache,
-        network: validated.network,
-    });
-    return {
-        content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
-        structuredContent: {
-            result: queryResult,
-            semantic: buildDataSemantic(queryResult, {
-                operation_type: "onchain_events",
-                data: validated,
-            }),
-        },
-    };
-}
-async function handleProjectOperation(args) {
-    const action = args.action;
-    const project = args.project;
-    const object = args.object;
-    let result;
-    switch (action) {
-        case "list_projects":
-            result = await queryProjects();
-            break;
-        case "list_objects":
-            if (!project)
-                throw new Error("'project' param is required for list_objects");
-            result = await queryProjectObjects(project);
-            break;
-        case "shareable":
-            result = await queryShareableObjects();
-            break;
-        case "dependencies":
-            if (!object)
-                throw new Error("'object' param is required for dependencies");
-            result = queryDependencies(object);
-            break;
-        case "referenced_by":
-            if (!object)
-                throw new Error("'object' param is required for referenced_by");
-            result = queryReferencedBy(object);
-            break;
-        case "pre_publish_check":
-            if (!object)
-                throw new Error("'object' param is required for pre_publish_check");
-            result = { warnings: queryPrePublishCheck(object) };
-            break;
-        case "cross_project_refs":
-            result = queryCrossProjectReferences();
-            break;
-        case "graph_stats":
-            result = queryGraphStats();
-            break;
-        case "save_graph":
-            result = { saved: true, path: saveGraph() };
-            break;
-        case "load_graph":
-            result = { loaded: loadGraph() };
-            break;
-        default:
-            throw new Error(`Unknown project_operation action: ${action}`);
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ result }) }],
-        structuredContent: { result },
-    };
-}
-async function handleConfigOperation(args) {
-    const action = args.action;
-    let result;
-    switch (action) {
-        case "list":
-            result = { services: listServices() };
-            break;
-        case "toggle": {
-            const service = args.service;
-            if (!service)
-                throw new Error("'service' param is required for toggle");
-            const existing = getServiceInfo(service);
-            if (!existing) {
-                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
-            }
-            const newState = toggleService(service);
-            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);
-            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);
-            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);
-            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");
-            const info = getServiceInfo(service);
-            if (!info)
-                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
-            result = info;
-            break;
-        }
-        default:
-            throw new Error(`Unknown config_operation action: ${action}`);
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ result }) }],
-        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 };
-    }
-    return input;
-}
-function normalizeManyAccountOrMark(input) {
-    if (Array.isArray(input)) {
-        return {
-            entities: input.map(item => typeof item === 'string' ? { name_or_address: item, local_mark_first: true } : item),
-            check_all_founded: true
-        };
-    }
-    return input;
-}
-async function handleMessengerOperation(args) {
-    let validated;
-    try {
-        validated = strictParse(MessengerOperationInputSchema, args, "messenger_operation input");
-        let result;
-        switch (validated.operation) {
-            case "watch_conversations": {
-                const conversations = await watch_conversations(validated.filter);
-                result = { operation: "watch_conversations", result: conversations };
-                break;
-            }
-            case "send_message": {
-                const sendResult = await send_message(validated.from, normalizeAccountOrMark(validated.to), validated.content, validated.options);
-                const filteredResult = {
-                    ...sendResult,
-                    merkleData: sendResult.merkleData ? {
-                        leafIndex: sendResult.merkleData.leafIndex,
-                        prevRoot: sendResult.merkleData.prevRoot,
-                        newRoot: sendResult.merkleData.newRoot,
-                        serverSignature: sendResult.merkleData.serverSignature,
-                        serverTimestamp: sendResult.merkleData.serverTimestamp,
-                        serverPublicKey: sendResult.merkleData.serverPublicKey,
-                    } : undefined,
-                };
-                result = { operation: "send_message", result: filteredResult };
-                break;
-            }
-            case "send_file": {
-                const sendResult = await send_file(validated.from, normalizeAccountOrMark(validated.to), validated.filePath, validated.options);
-                const filteredResult = {
-                    ...sendResult,
-                    merkleData: sendResult.merkleData ? {
-                        leafIndex: sendResult.merkleData.leafIndex,
-                        prevRoot: sendResult.merkleData.prevRoot,
-                        newRoot: sendResult.merkleData.newRoot,
-                        serverSignature: sendResult.merkleData.serverSignature,
-                        serverTimestamp: sendResult.merkleData.serverTimestamp,
-                        serverPublicKey: sendResult.merkleData.serverPublicKey,
-                    } : undefined,
-                };
-                result = { operation: "send_file", result: filteredResult };
-                break;
-            }
-            case "watch_messages": {
-                const filter = validated.filter ? {
-                    ...validated.filter,
-                    peerAddress: validated.filter.peerAddress ? normalizeAccountOrMark(validated.filter.peerAddress) : undefined
-                } : undefined;
-                const messages = await watch_messages(filter);
-                result = { operation: "watch_messages", result: messages };
-                break;
-            }
-            case "extract_zip_messages": {
-                const extractedPaths = await extract_zip_messages(validated.account, validated.messages, validated.outputDir);
-                result = { operation: "extract_zip_messages", result: extractedPaths };
-                break;
-            }
-            case "generate_wts": {
-                const params = validated.params ? {
-                    ...validated.params,
-                    peerAccount: normalizeAccountOrMark(validated.params.peerAccount)
-                } : undefined;
-                const wtsResult = await generate_wts(params);
-                result = { operation: "generate_wts", result: wtsResult };
-                break;
-            }
-            case "verify_wts": {
-                const verifyResult = await verify_wts(validated.wtsFilePath);
-                result = { operation: "verify_wts", result: verifyResult };
-                break;
-            }
-            case "sign_wts": {
-                const signedPath = await sign_wts(validated.wtsFilePath, validated.account, validated.outputPath);
-                result = { operation: "sign_wts", result: signedPath };
-                break;
-            }
-            case "wts2html": {
-                const htmlResult = await wts2html(validated.wtsPath, validated.options);
-                result = { operation: "wts2html", result: htmlResult };
-                break;
-            }
-            case "proof_message": {
-                const proofResult = await proof_message(validated.account, validated.messageId, validated.network);
-                result = { operation: "proof_message", result: proofResult };
-                break;
-            }
-            case "blacklist": {
-                const blacklistParams = {
-                    account: validated.account,
-                    op: validated.blacklist.op
-                };
-                if ('users' in validated.blacklist) {
-                    blacklistParams.users = normalizeManyAccountOrMark(validated.blacklist.users);
-                }
-                const blacklistResult = await blacklist(blacklistParams);
-                result = { operation: "blacklist", op: validated.blacklist.op, result: blacklistResult.result };
-                break;
-            }
-            case "friendslist": {
-                const friendslistParams = {
-                    account: validated.account,
-                    op: validated.friendslist.op
-                };
-                if ('users' in validated.friendslist) {
-                    friendslistParams.users = normalizeManyAccountOrMark(validated.friendslist.users);
-                }
-                const friendslistResult = await friendslist(friendslistParams);
-                result = { operation: "friendslist", op: validated.friendslist.op, result: friendslistResult.result };
-                break;
-            }
-            case "guardlist": {
-                const guardlistResult = await guardlist({
-                    account: validated.account,
-                    ...validated.guardlist
-                });
-                result = { operation: "guardlist", op: validated.guardlist.op, result: guardlistResult.result };
-                break;
-            }
-            case "settings": {
-                const settingsResult = await settings({
-                    account: validated.account,
-                    ...validated.settings
-                });
-                result = { operation: "settings", op: validated.settings.op, result: settingsResult.result };
-                break;
-            }
-            case "mark_messages_as_viewed": {
-                const markedCount = await mark_messages_as_viewed(validated.messageIds, validated.account);
-                result = { operation: "mark_messages_as_viewed", result: markedCount };
-                break;
-            }
-            case "mark_conversation_as_viewed": {
-                const markedCount = await mark_conversation_as_viewed(normalizeAccountOrMark(validated.peerAddress), validated.account);
-                result = { operation: "mark_conversation_as_viewed", result: markedCount };
-                break;
-            }
-            case "pull_messages": {
-                const messages = await pull_messages(validated.account, validated.limit);
-                result = { operation: "pull_messages", result: messages };
-                break;
-            }
-            default:
-                throw new Error(`Unknown messenger operation: ${validated.operation}`);
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: { result },
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const ctx = validated ? { operation_type: "messenger_" + validated.operation, data: validated } : undefined;
-        const classified = classifyError(errorMessage);
-        const errorResult = { operation: "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 handleGuard2File(args) {
-    const validated = strictParse(Guard2File_InputSchema, args, "guard2file input");
-    const env = getEnvConfig(validated.env);
-    try {
-        await guard2file(validated.guard, validated.file_path, validated.format || "json", env.network);
-        const result = {
-            result: {
-                status: "success",
-                data: {
-                    file_path: resolve(validated.file_path),
-                    format: validated.format || "json",
-                    guard_object: validated.guard,
-                },
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        const result = {
-            result: {
-                status: "error",
-                error: error.message,
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-}
-async function handleMachineNode2File(args) {
-    const validated = strictParse(MachineNode2File_InputSchema, args, "machineNode2file input");
-    const env = getEnvConfig(validated.env);
-    try {
-        await machineNode2file(validated.machine, validated.file_path, validated.format || "json", env.network);
-        let node_count = undefined;
-        try {
-            const filePath = resolve(validated.file_path);
-            const fileContent = await import('fs/promises').then(fs => fs.readFile(filePath, 'utf-8'));
-            if ((validated.format || "json") === "json") {
-                const parsed = JSON.parse(fileContent);
-                if (Array.isArray(parsed)) {
-                    node_count = parsed.length;
-                }
-            }
-            else {
-                const nodeMatches = fileContent.match(/^##\s+Node:/gm);
-                node_count = nodeMatches ? nodeMatches.length : 0;
-            }
-        }
-        catch {
-            node_count = undefined;
-        }
-        const result = {
-            result: {
-                status: "success",
-                data: {
-                    file_path: resolve(validated.file_path),
-                    format: validated.format || "json",
-                    machine_object: validated.machine,
-                },
-            },
-        };
-        if (node_count !== undefined) {
-            result.result.data.node_count = node_count;
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        const result = {
-            result: {
-                status: "error",
-                error: error.message,
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-}
-export { OnchainOperationsSchema, WipOperationsSchema, WatchQueryOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, ProtocolInfoQuerySchema, CallOutputSchema, MessengerOperationInputSchema, MessengerOperationOutputSchema };
+export { OnchainOperationsSchema, WipOperationsSchema, WatchQueryOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, ProtocolInfoQuerySchema, CallOutputSchema, MessengerOperationInputSchema, MessengerOperationOutputSchema, };
 async function main() {
     if (areSchemasAvailable()) {
         const index = getSchemaIndex();
@@ -1420,342 +142,7 @@ async function main() {
     }
     const activeServices = listServices().filter((s) => s.enabled).map((s) => s.name);
     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).\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 },
-        _meta: createToolMeta("operation", ["service", "machine", "progress", "repository", "arbitration", "contact", "treasury", "reward", "allocation", "permission", "guard", "personal", "payment", "demand", "order", "gen_passport", "proof", "gen_proof", "on-chain", "blockchain"]),
-    }, 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.\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 },
-        _meta: createToolMeta("operation", ["account", "local", "private", "wallet", "off-chain"]),
-    }, 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.\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 },
-        _meta: createToolMeta("operation", ["mark", "local", "private", "address-book", "off-chain"]),
-    }, 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.\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 },
-        _meta: createToolMeta("operation", ["info", "local", "private", "data-management", "off-chain"]),
-    }, 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).\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,
-        }),
-        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-        _meta: createToolMeta("operation", ["wip", "promise", "file-generation", "verification", "signature", "local"]),
-    }, 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.\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 },
-        _meta: createToolMeta("operation", ["messenger", "message", "file", "wts", "blacklist", "friendslist", "guardlist", "settings", "proof", "communication"]),
-    }, 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.\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 },
-        _meta: createToolMeta("generate file", ["guard", "export", "file", "json", "markdown", "on-chain"]),
-    }, 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.\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 },
-        _meta: createToolMeta("generate file", ["machine", "export", "file", "json", "markdown", "on-chain", "workflow"]),
-    }, handleMachineNode2File, strictStatusErrorShape);
-    reg("query_toolkit", {
-        title: "🔍 Data Query Toolkit",
-        description: "WOWOK data query toolkit — 9 query types covering local device data and on-chain blockchain data:\n\n"
-            + "LOCAL (device-only, never on-chain):\n"
-            + "1. local_mark_list — Query your LOCAL address book: maps human-readable names to blockchain addresses with optional tags. Use to resolve names→addresses or find addresses by tag.\n"
-            + "2. account_list — Query your LOCAL accounts (addresses, messenger status, suspension state). Use filter.includePubkey=true to also include public keys. Use to discover available accounts before operations.\n"
-            + "3. local_info_list — Query your LOCAL private info: sensitive data like delivery addresses, phone numbers, contacts stored ONLY on this device.\n"
-            + "4. token_list — Query cached token metadata: symbol, decimals, icon URL, description for tokens previously fetched from chain. Use to look up token precision/decimals before performing token operations. Returns: TokenTypeInfo[] (type, alias, name, symbol, decimals, iconUrl).\n"
-            + "5. account_balance — Query an account's coin balance OR paginated coin objects. Use balance=true for total amount, or coin={cursor,limit} to list individual coin objects. Supports multi-token via token_type parameter.\n"
-            + "6. local_names — Query local names by a list of addresses. For each address, returns the resolved account name (if exists) and local mark name (if exists). Returns: { account?, local_mark?, address }[].\n\n"
-            + "ONCHAIN (blockchain):\n"
-            + "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.\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[]."),
-            semantic: z.unknown().optional().describe("Business semantic summary for the query operation"),
-        }),
-        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-        _meta: createToolMeta("query", ["watch", "query", "on-chain", "local", "events", "objects", "tokens", "balance", "profile"]),
-    }, handleWatchQueryOperations);
-    reg("onchain_table_data", {
-        title: "📊 Watch WoWok On-chain Table Data Query",
-        description: "Query dynamic table data of on-chain objects — supports paginated table queries and specific table item lookups. Each table item belongs to a parent object type and has a specific meaning:\n\n"
-            + "1. onchain_table — Paginated query of ANY object's dynamic fields table (Parent: any object). Returns all entries with keys, types, and object IDs. Use to explore all sub-items of an object.\n"
-            + "2. onchain_table_item_repository_data — Query a record from a Repository's on-chain key-value database (Parent: Repository). Key: name + entity (address or number). Returns the stored data record with typed value.\n"
-            + "3. onchain_table_item_permission_perm — Query a permission entry from a Permission object's access control table (Parent: Permission). Key: user address or Guard ID. Returns the permission list (perm[]) granted to that user/guard.\n"
-            + "4. onchain_table_item_entity_registrar — Query an entity's registration record from the GLOBAL EntityRegistrar (Parent: system EntityRegistrar). Key: user address. Returns registration info: description, referrer, records, mark_object.\n"
-            + "5. onchain_table_item_entity_linker — Query community votes/endorsements for an entity from the GLOBAL EntityLinker (Parent: system EntityLinker). Key: entity address. Returns vote records (likes/dislikes) showing community trust.\n"
-            + "6. onchain_table_item_reward_record — Query a reward claim record from a Reward object's distribution table (Parent: Reward). Key: recipient address. Returns claim history: guard used, total claimed, per-claim details.\n"
-            + "7. onchain_table_item_demand_presenter — Query a demand submission from a Demand object's presenter table (Parent: Demand). Key: presenter address. Returns submission details: recommendation, service, feedback, acceptance score.\n"
-            + "8. onchain_table_item_treasury_history — Query a payment record from a Treasury's history table (Parent: Treasury). Key: payment ID (address). Returns payment details: operation type, signer, amount, external guard.\n"
-            + "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.\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 },
-        _meta: createToolMeta("table query", ["on-chain", "table", "dynamic fields", "pagination", "repository", "permission", "reward", "demand", "treasury", "machine", "progress"]),
-    }, 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.\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 },
-        _meta: createToolMeta("watch wowook events", ["events", "on-chain", "arbitration", "order", "progress", "demand", "entity"]),
-    }, handleOnchainEvents);
-    reg("wowok_buildin_info", {
-        title: "ℹ️ WoWok Build-in Information",
-        description: "Query WoWok protocol information: 'constants', 'built-in permissions', 'guard instructions', 'current network', 'value types', or 'mainnet bridge tokens'. For 'mainnet bridge tokens': returns cross-chain bridge tokens (ETH, WETH, WBTC, USDC, USDT) with each token's symbol, WOW-side type tag (wowTypeTag), EVM address, decimals, and description. The wowTypeTag (format {address}::{module}::{struct}) can be used directly as the `type_parameter` of Service / Treasury / Reward / Allocation objects to set their payment token — e.g. use USDT's wowTypeTag to create a Service that accepts USDT payments.",
-        inputSchema: ProtocolInfoQuerySchema,
-        outputSchema: ProtocolInfoResultSchema,
-        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-        _meta: createToolMeta("WoWok info", ["build-in", "constants", "permissions", "guard", "network", "value-types", "bridge-tokens"]),
-    }, handleWowokInfo);
-    reg("schema_query", {
-        title: "📋 Schema Query",
-        description: "Look up JSON Schemas for WoWok MCP tools and on-chain operations. " +
-            "This is the authoritative reference for exact parameter structures, types, and required fields. " +
-            "Always check the schema before calling an unfamiliar tool.\n\n" +
-            "Actions:\n" +
-            "  'list' - Show all available schemas (tools + on-chain operations). Start here to discover what exists.\n" +
-            "  'get' - Fetch the full input JSON Schema by name (e.g. 'onchain_operations'). Use with the 'name' param.\n" +
-            "  '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: SchemaQueryInputSchema,
-        outputSchema: SchemaQueryOutputSchema,
-        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-        _meta: createToolMeta("schema", ["schema", "json-schema", "types", "structure", "validation", "reference"]),
-    }, async (args) => {
-        const request = {
-            action: args.action,
-            name: args.name,
-            query: args.query,
-        };
-        const response = processSchemaQuery(request);
-        let textContent = response.message;
-        const data = response.data;
-        if (response.success && data) {
-            switch (args.action) {
-                case "list":
-                    if (Array.isArray(data) && data.length > 0) {
-                        textContent += "\n\nAll available schemas:\n";
-                        for (const item of data) {
-                            textContent += `\n  • ${item.name}`;
-                            if (item.title) {
-                                textContent += ` - ${item.title}`;
-                            }
-                            if (item.description) {
-                                textContent += `\n    ${item.description.slice(0, 100)}...`;
-                            }
-                            textContent += "\n";
-                        }
-                    }
-                    break;
-                case "list_operations":
-                    if (Array.isArray(data) && data.length > 0) {
-                        textContent += "\n\nOn-chain operation schemas:\n";
-                        for (const item of data) {
-                            textContent += `\n  • ${item.name}`;
-                            if (item.title) {
-                                textContent += ` - ${item.title}`;
-                            }
-                            if (item.description) {
-                                textContent += `\n    ${item.description.slice(0, 100)}...`;
-                            }
-                            textContent += "\n";
-                        }
-                    }
-                    break;
-                case "get":
-                    if (data) {
-                        textContent += "\n\n## JSON Schema\n\n";
-                        textContent += "```json\n";
-                        textContent += JSON.stringify(data, null, 2);
-                        textContent += "\n```\n";
-                    }
-                    break;
-                case "get_output":
-                    if (data) {
-                        textContent += "\n\n## Output JSON Schema\n\n";
-                        textContent += "```json\n";
-                        textContent += JSON.stringify(data, null, 2);
-                        textContent += "\n```\n";
-                    }
-                    break;
-                case "search":
-                    if (Array.isArray(data) && data.length > 0) {
-                        textContent += `\n\nFound ${data.length} schemas matching '${args.query}':\n`;
-                        for (const item of data) {
-                            textContent += `\n  • ${item.name}`;
-                            if (item.title) {
-                                textContent += ` - ${item.title}`;
-                            }
-                            if (item.description) {
-                                textContent += `\n    ${item.description.slice(0, 100)}...`;
-                            }
-                            textContent += "\n";
-                        }
-                    }
-                    else {
-                        textContent += "\n\nNo schemas found. Try 'list' to browse all available schemas, or use a broader search term.";
-                    }
-                    break;
-            }
-        }
-        if (response.suggestions && response.suggestions.length > 0) {
-            textContent += "\n\n💡 Suggestions:\n";
-            for (const suggestion of response.suggestions) {
-                textContent += `  • ${suggestion}\n`;
-            }
-        }
-        return {
-            content: [{
-                    type: "text",
-                    text: textContent,
-                }],
-            structuredContent: response,
-        };
-    });
-    reg("bridge_operation", {
-        title: "🌉 Bridge - Cross-Chain Operations",
-        description: "🌉 Simplified cross-chain bridge between WOW and EVM (Ethereum mainnet). Only WOW mainnet provides cross-chain functionality.\n\n" +
-            "Key concepts (transparent to user):\n" +
-            "  • Global single activeEvmAccount - auto-generated on first use, holds cross-chain assets.\n" +
-            "  • WOW→EVM: assets auto-claim to activeEvmAccount; optional withdrawTo transfers to a final EVM address.\n" +
-            "  • EVM→WOW: deposit from activeEvmAccount (balance checked first), assets arrive at the WOW account.\n\n" +
-            "Operations (operation_type):\n" +
-            "  • cross_chain_wow_to_evm - WOW→EVM cross-chain (asset to activeEvmAccount or withdrawTo). [Requires WOW mainnet env]\n" +
-            "  • cross_chain_evm_to_wow - EVM→WOW cross-chain (from activeEvmAccount to WOW account). [Requires WOW mainnet env]\n" +
-            "  • withdraw - Withdraw from activeEvmAccount to another EVM address (non-cross-chain). [No env needed]\n" +
-            "  • query_active_evm_account - Query activeEvmAccount address + balances (per chain or all). [No env needed]\n" +
-            "  • query_supported_evm_chains - List supported EVM chains (enum/description/chainId/RPC health). [No env needed]\n" +
-            "  • query_supported_tokens - List supported Bridge tokens per chain (WOW/EVM contract addresses, decimals, description). [No env needed]\n" +
-            "  • query_transfer_list - Query transfer history list with optional filters (status/direction/token/limit). [No env needed]\n" +
-            "  • query_transfer_status - Query single transfer detail by transferId. [No env needed]\n" +
-            "  • manage_evm_rpc - Manage EVM RPC endpoints (list/add/remove/set/ping) to handle 429 rate limits. [No env needed]\n\n" +
-            "Token support follows SDK config (ETH/WETH/WBTC/USDC/USDT). WOW account names are supported (resolved via LocalMark).\n" +
-            "NOTE: Use schema_query (name='bridge_operation') to retrieve the exact JSON Schema with all field definitions before calling.",
-        inputSchema: BridgeOperationsSchema,
-        outputSchema: BridgeCallOutputSchema,
-        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
-        _meta: createToolMeta("operation", ["bridge", "cross-chain", "evm", "ethereum", "wow", "transfer", "rpc"]),
-    }, handleBridgeOperations);
-    reg("project_operation", {
-        title: "🗂️ Project - Namespace & Object Graph",
-        description: "Phase 2 project namespace service — manage and query the local object dependency graph (DAG) " +
-            "built on top of local_mark tags. No on-chain writes; all data comes from local marks tagged " +
-            "`project:<prefix>` (auto-injected by the ProjectService when enabled, default ON).\n\n" +
-            "Actions:\n" +
-            "  • list_projects — List all discovered projects (grouped by `project:<prefix>` tag) with object counts.\n" +
-            "  • list_objects — List objects in a project (requires `project` param).\n" +
-            "  • shareable — List objects tagged `shareable:true` (cross-project reusable: common Permission, 3rd-party Arb).\n" +
-            "  • dependencies — Trace forward dependencies of an object (BFS transitive closure + dangling refs).\n" +
-            "  • referenced_by — Reverse query: who references this object?\n" +
-            "  • pre_publish_check — Pre-publish sanity check for a service (dangling deps + cycles).\n" +
-            "  • cross_project_refs — Find edges that cross project boundaries.\n" +
-            "  • graph_stats — Graph statistics (node/edge counts, cycles, dangling deps).\n" +
-            "  • save_graph — Save the in-memory graph to ~/.wowok/project-graph.json (persist across sessions).\n" +
-            "  • 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).\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);
-    reg("config_operation", {
-        title: "⚙️ Config - Runtime Service Toggles",
-        description: "Phase 2 runtime configuration — toggle Phase 2 services on/off at runtime WITHOUT restarting the MCP server. " +
-            "This is the session-level switch mechanism: AI can toggle based on user conversation context, or users can " +
-            "directly control which Phase 2 features are active.\n\n" +
-            "Actions:\n" +
-            "  • list — List all services with current state + reminders.\n" +
-            "  • toggle — Toggle a service on/off (requires `service` param). Returns reminder text.\n" +
-            "  • enable — Enable a service (requires `service` param).\n" +
-            "  • disable — Disable a service (requires `service` param).\n" +
-            "  • reset — Reset a service to its default (requires `service` param).\n" +
-            "  • info — Get detailed info about a service (requires `service` param).\n\n" +
-            "Services:\n" +
-            "  • confirm_gate — Safety Confirmation Gate (default ON)\n" +
-            "  • 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" +
-            "  • 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.\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);
+    registerAllTools(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     process.on("SIGINT", async () => {