@wowok/agent-mcp 2.6.1 → 2.6.3

package/dist/schema/schema-query/index.d.ts

@@ -1,20 +1,20 @@
 import { z } from "zod";
 export declare const SchemaQueryInputSchema: z.ZodObject<{
-    action: z.ZodEnum<["list", "get", "get_output", "search", "list_operations", "get_guard_templates", "get_field"]>;
+    action: z.ZodEnum<["list", "get", "get_output", "search", "list_operations", "get_guard_templates", "get_field", "search_examples"]>;
     name: z.ZodOptional<z.ZodString>;
     query: z.ZodOptional<z.ZodString>;
     field_path: z.ZodOptional<z.ZodString>;
     template: z.ZodOptional<z.ZodString>;
     output_file: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    action: "get" | "search" | "list" | "get_output" | "list_operations" | "get_guard_templates" | "get_field";
+    action: "get" | "search" | "list" | "get_output" | "list_operations" | "get_guard_templates" | "get_field" | "search_examples";
     name?: string | undefined;
     query?: string | undefined;
     field_path?: string | undefined;
     template?: string | undefined;
     output_file?: string | undefined;
 }, {
-    action: "get" | "search" | "list" | "get_output" | "list_operations" | "get_guard_templates" | "get_field";
+    action: "get" | "search" | "list" | "get_output" | "list_operations" | "get_guard_templates" | "get_field" | "search_examples";
     name?: string | undefined;
     query?: string | undefined;
     field_path?: string | undefined;
@@ -36,6 +36,36 @@ export declare const SchemaQueryOutputSchema: z.ZodObject<{
         name: string;
         description?: string | undefined;
         title?: string | undefined;
+    }>, "many">, z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        tags: z.ZodArray<z.ZodString, "many">;
+        industry: z.ZodString;
+        operation_type: z.ZodString;
+        verified: z.ZodBoolean;
+        score: z.ZodNumber;
+        matched_fields: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        description: string;
+        title: string;
+        score: number;
+        tags: string[];
+        file: string;
+        industry: string;
+        operation_type: string;
+        verified: boolean;
+        matched_fields: string[];
+    }, {
+        description: string;
+        title: string;
+        score: number;
+        tags: string[];
+        file: string;
+        industry: string;
+        operation_type: string;
+        verified: boolean;
+        matched_fields: string[];
     }>, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>;
     message: z.ZodString;
     suggestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -46,6 +76,16 @@ export declare const SchemaQueryOutputSchema: z.ZodObject<{
         name: string;
         description?: string | undefined;
         title?: string | undefined;
+    }[] | {
+        description: string;
+        title: string;
+        score: number;
+        tags: string[];
+        file: string;
+        industry: string;
+        operation_type: string;
+        verified: boolean;
+        matched_fields: string[];
     }[] | null;
     success: boolean;
     action: string;
@@ -57,6 +97,16 @@ export declare const SchemaQueryOutputSchema: z.ZodObject<{
         name: string;
         description?: string | undefined;
         title?: string | undefined;
+    }[] | {
+        description: string;
+        title: string;
+        score: number;
+        tags: string[];
+        file: string;
+        industry: string;
+        operation_type: string;
+        verified: boolean;
+        matched_fields: string[];
     }[] | null;
     success: boolean;
     action: string;

package/dist/schema/schema-query/index.js

@@ -10,8 +10,9 @@ export const SchemaQueryInputSchema = z
         "list_operations",
         "get_guard_templates",
         "get_field",
+        "search_examples",
     ])
-        .describe("Action to perform: 'list' (all schemas), 'get' (specific input schema), 'get_output' (tool output schema), 'get_field' (field-path query e.g. field_path='data.node'), 'search' (by keyword), 'list_operations' (on-chain operations), 'get_guard_templates' (Guard creation templates + best practices)."),
+        .describe("Action to perform: 'list' (all schemas), 'get' (specific input schema), 'get_output' (tool output schema), 'get_field' (field-path query e.g. field_path='data.node'), 'search' (by keyword), 'list_operations' (on-chain operations), 'get_guard_templates' (Guard creation templates + best practices), 'search_examples' (search verified example files by keyword — matches title, description, tags, operation_type, industry)."),
     name: z
         .string()
         .optional()
@@ -41,6 +42,19 @@ const SchemaListItemSchema = z
     description: z.string().optional().describe("Short description, if known."),
 })
     .strict();
+const ExampleSearchResultSchema = z
+    .object({
+    file: z.string().describe("Example file name (e.g. 'rental-ziroom-service-create.json')."),
+    title: z.string().describe("Human-readable title from the example metadata."),
+    description: z.string().describe("Longer description from the example metadata."),
+    tags: z.array(z.string()).describe("Tags from the example metadata."),
+    industry: z.string().describe("Industry category (e.g. 'rental', 'retail', 'general')."),
+    operation_type: z.string().describe("Operation type (e.g. 'service', 'machine', 'guard', 'permission')."),
+    verified: z.boolean().describe("Whether the example is marked as verified."),
+    score: z.number().describe("Relevance score — number of fields that matched the query (0-5)."),
+    matched_fields: z.array(z.string()).describe("List of fields that matched the query."),
+})
+    .strict();
 export const SchemaQueryOutputSchema = z
     .object({
     success: z.boolean().describe("Whether the request was successful"),
@@ -48,10 +62,11 @@ export const SchemaQueryOutputSchema = z
     data: z
         .union([
         z.array(SchemaListItemSchema).describe("List of schema summaries (list/search/list_operations)."),
+        z.array(ExampleSearchResultSchema).describe("List of matching examples (search_examples)."),
         z.record(z.unknown()).describe("JSON Schema object (get/get_output/get_field) or Guard template data."),
         z.null().describe("No data — lookup failed or returned nothing, or data was written to output_file."),
     ])
-        .describe("Response data — array of schema summaries for list-like actions, JSON Schema object for get/get_output/get_field, Guard template data for get_guard_templates, null on failure or when output_file is used."),
+        .describe("Response data — array of schema summaries for list-like actions, array of example results for search_examples, JSON Schema object for get/get_output/get_field, Guard template data for get_guard_templates, null on failure or when output_file is used."),
     message: z.string().describe("Human-readable message describing the result"),
     suggestions: z
         .array(z.string())

package/dist/schema/utils/node-parser.js

@@ -249,6 +249,19 @@ export function parseMachineNodesFromText(text) {
     if (errors.length > 0) {
         return { success: false, errors };
     }
+    const hasEntryForward = nodes.some(node => node.pairs.some(pair => pair.prev_node === ""));
+    if (!hasEntryForward) {
+        return {
+            success: false,
+            errors: [{
+                    message: 'Machine has no entry forward. At least one node must have a pair with prev_node="" (empty string), ' +
+                        'which defines how Progress advances from the initial state (current="") to the first node. ' +
+                        'Without an entry forward, the workflow will be permanently stuck. ' +
+                        'Example: {name: "Subscribed", pairs: [{prev_node: "", forwards: [{name: "Subscribe", weight: 1}]}]}',
+                    path: '/',
+                }]
+        };
+    }
     return { success: true, data: nodes, errors: [] };
 }
 export function formatNodeErrors(errors) {

package/dist/schema/utils/object-type-utils.d.ts

@@ -0,0 +1,12 @@
+export declare function shortTypeName(objectType: string | null | undefined): string;
+export declare function normalizeObjectType(objectType: string | null | undefined): string;
+export declare function isObjectOfType(objectType: string | null | undefined, expectedShortName: string): boolean;
+export declare function groupObjectsByType<T extends {
+    objectType: string | null;
+}>(objects: T[]): Map<string, T[]>;
+export declare function findObjectByType<T extends {
+    objectType: string | null;
+}>(objects: T[], expectedShortName: string): T | undefined;
+export declare function countObjectsByType<T extends {
+    objectType: string | null;
+}>(objects: T[], expectedShortName: string): number;

package/dist/schema/utils/object-type-utils.js

@@ -0,0 +1,35 @@
+export function shortTypeName(objectType) {
+    if (!objectType)
+        return "unknown";
+    const base = objectType.replace(/<.*>/, "").trim();
+    const segments = base.split("::");
+    const shortName = segments[segments.length - 1] || "unknown";
+    if (shortName.length > 0 && shortName === shortName.toLowerCase()) {
+        return shortName.charAt(0).toUpperCase() + shortName.slice(1);
+    }
+    return shortName;
+}
+export function normalizeObjectType(objectType) {
+    return shortTypeName(objectType).toLowerCase();
+}
+export function isObjectOfType(objectType, expectedShortName) {
+    const normalized = normalizeObjectType(objectType);
+    const expected = expectedShortName.toLowerCase();
+    return normalized === expected;
+}
+export function groupObjectsByType(objects) {
+    const byType = new Map();
+    for (const obj of objects) {
+        const t = shortTypeName(obj.objectType);
+        if (!byType.has(t))
+            byType.set(t, []);
+        byType.get(t).push(obj);
+    }
+    return byType;
+}
+export function findObjectByType(objects, expectedShortName) {
+    return objects.find(o => isObjectOfType(o.objectType, expectedShortName));
+}
+export function countObjectsByType(objects, expectedShortName) {
+    return objects.filter(o => isObjectOfType(o.objectType, expectedShortName)).length;
+}

package/dist/schema/utils/permission-machine-check.d.ts

@@ -0,0 +1,49 @@
+export interface ForwardPermissionRef {
+    nodeName: string;
+    prevNode: string;
+    forwardName: string;
+    permissionIndex: number | null;
+    namedOperator: string | null;
+}
+export interface PermissionRefCollection {
+    indexRefs: ForwardPermissionRef[];
+    namedRefs: ForwardPermissionRef[];
+    missingRefs: ForwardPermissionRef[];
+    requiredIndexes: number[];
+}
+export interface IndexAuthorizationStatus {
+    index: number;
+    authorized: boolean;
+    entityCount: number;
+}
+export interface PermissionAuthorizationReport {
+    statuses: IndexAuthorizationStatus[];
+    missingIndexes: number[];
+    authorizedIndexes: number[];
+    allAuthorized: boolean;
+    summary: string;
+}
+export declare function collectPermissionIndexes(nodes: Array<{
+    name: string;
+    pairs?: Array<{
+        prev_node: string;
+        forwards?: Array<{
+            name: string;
+            permissionIndex?: number | null;
+            namedOperator?: string | null;
+        }>;
+    }>;
+}>): PermissionRefCollection;
+export interface PermissionObjectData {
+    address?: string;
+    entity_count?: number;
+    perm_remark?: Array<{
+        index: number;
+        remark: string;
+    }>;
+    entityPermissions?: Map<string, number[]>;
+    owner?: string;
+    admin?: string[];
+}
+export declare function checkPermissionAuthorization(requiredIndexes: number[], permission: PermissionObjectData | null | undefined): PermissionAuthorizationReport;
+export declare function formatPermissionWarning(report: PermissionAuthorizationReport): string;

package/dist/schema/utils/permission-machine-check.js

@@ -0,0 +1,121 @@
+export function collectPermissionIndexes(nodes) {
+    const indexRefs = [];
+    const namedRefs = [];
+    const missingRefs = [];
+    const requiredIndexSet = new Set();
+    for (const node of nodes) {
+        if (!node.pairs)
+            continue;
+        for (const pair of node.pairs) {
+            if (!pair.forwards)
+                continue;
+            for (const forward of pair.forwards) {
+                const ref = {
+                    nodeName: node.name,
+                    prevNode: pair.prev_node,
+                    forwardName: forward.name,
+                    permissionIndex: forward.permissionIndex ?? null,
+                    namedOperator: forward.namedOperator ?? null,
+                };
+                if (ref.permissionIndex != null) {
+                    indexRefs.push(ref);
+                    requiredIndexSet.add(ref.permissionIndex);
+                }
+                else if (ref.namedOperator != null && ref.namedOperator !== "") {
+                    namedRefs.push(ref);
+                }
+                else {
+                    missingRefs.push(ref);
+                }
+            }
+        }
+    }
+    return {
+        indexRefs,
+        namedRefs,
+        missingRefs,
+        requiredIndexes: Array.from(requiredIndexSet).sort((a, b) => a - b),
+    };
+}
+export function checkPermissionAuthorization(requiredIndexes, permission) {
+    const BUILTIN_THRESHOLD = 1000;
+    const statuses = [];
+    const missingIndexes = [];
+    const authorizedIndexes = [];
+    for (const index of requiredIndexes) {
+        if (index < BUILTIN_THRESHOLD) {
+            statuses.push({ index, authorized: true, entityCount: -1 });
+            authorizedIndexes.push(index);
+            continue;
+        }
+        let authorized = false;
+        let entityCount = 0;
+        if (permission?.entityPermissions) {
+            for (const perms of permission.entityPermissions.values()) {
+                if (perms.includes(index)) {
+                    entityCount++;
+                }
+            }
+            authorized = entityCount > 0;
+        }
+        else if (permission?.perm_remark && permission.perm_remark.length > 0) {
+            authorized = permission.perm_remark.some(r => r.index === index);
+            entityCount = authorized ? -1 : 0;
+        }
+        else {
+            authorized = true;
+            entityCount = -1;
+        }
+        statuses.push({ index, authorized, entityCount });
+        if (authorized) {
+            authorizedIndexes.push(index);
+        }
+        else {
+            missingIndexes.push(index);
+        }
+    }
+    const allAuthorized = missingIndexes.length === 0;
+    const summary = allAuthorized
+        ? `All ${requiredIndexes.length} required permission index(es) are authorized.`
+        : `${missingIndexes.length}/${requiredIndexes.length} required permission index(es) are NOT authorized: [${missingIndexes.join(", ")}]. ` +
+            `Forwards using these indexes will be un-executable — Progress will be stuck. ` +
+            `Grant entities for these indexes via permission.op="add perm by index" before publishing the Machine.`;
+    return {
+        statuses,
+        missingIndexes,
+        authorizedIndexes,
+        allAuthorized,
+        summary,
+    };
+}
+export function formatPermissionWarning(report) {
+    if (report.allAuthorized) {
+        return "";
+    }
+    const lines = [
+        "CRITICAL PRE-PUBLISH: Machine forwards reference permission indexes that are NOT authorized in the Permission object.",
+        "",
+        `Missing indexes (no entities granted): ${report.missingIndexes.join(", ")}`,
+        "",
+        "Impact: Forwards using these indexes can NEVER be executed — Progress will be permanently stuck at the source node.",
+        "Buyer funds may be trapped if the workflow cannot advance past the stuck node.",
+        "",
+        "To fix BEFORE publishing:",
+        '  1. Call onchain_operations with op="permission"',
+        '  2. Set object=<your_permission_name_or_address>',
+        '  3. Set permission.op="add perm by index"',
+        "  4. Set index=<missing_index> for each missing index",
+        '  5. Set entity=["<entity_address>"] — the address that should be authorized',
+        "  6. After granting all missing indexes, re-attempt the Machine publish.",
+        "",
+        "Required permission indexes for this Machine:",
+    ];
+    for (const status of report.statuses) {
+        const state = status.authorized ? "AUTHORIZED" : "MISSING";
+        const count = status.entityCount === -1
+            ? "(built-in or heuristic)"
+            : `(${status.entityCount} entity/entities)`;
+        lines.push(`  - Index ${status.index}: ${state} ${count}`);
+    }
+    return lines.join("\n");
+}

package/dist/schema/utils/skills-recommendation.d.ts

@@ -0,0 +1,2 @@
+export declare function getSkillsHintForOnchain(operationType: string, data?: unknown): string | undefined;
+export declare function getSkillsHintForProject(action: string): string | undefined;

package/dist/schema/utils/skills-recommendation.js

@@ -0,0 +1,76 @@
+const SKILLS_BY_OPERATION_TYPE = {
+    service: ["wowok-provider", "wowok-safety"],
+    machine: ["wowok-machine"],
+    guard: ["wowok-guard"],
+    arbitration: ["wowok-arbitrator"],
+    allocation: ["wowok-provider"],
+    permission: ["wowok-safety"],
+    treasury: ["wowok-provider", "wowok-safety"],
+    reward: ["wowok-provider"],
+    repository: ["wowok-provider"],
+    demand: ["wowok-provider"],
+    contact: ["wowok-messenger"],
+    order: ["wowok-order"],
+    progress: [],
+    personal: [],
+    payment: [],
+    proof: [],
+};
+const SKILLS_BY_PROJECT_ACTION = {
+    create_project: ["wowok-onboard", "wowok-planner"],
+    create_project_from_onchain: ["wowok-onboard"],
+    evaluate_project: ["wowok-auditor"],
+    pre_evaluate_check: ["wowok-auditor"],
+    verify_deployment: ["wowok-auditor"],
+    generate_deployment_doc: ["wowok-planner"],
+    migrate_to_mainnet: ["wowok-onboard", "wowok-safety"],
+    migrate_network: ["wowok-onboard"],
+    clone_project_to_network: ["wowok-onboard"],
+    build_graph: ["wowok-planner"],
+    list_projects: [],
+    get_project_detail: [],
+    update_project: [],
+    add_object: [],
+    remove_object: [],
+    update_object: [],
+    create_version: [],
+    get_graph: [],
+    save_evaluation: [],
+    compare_projects: [],
+    refresh_objects: [],
+    get_object_diff: [],
+    delete_project: [],
+    assemble_context: [],
+    get_machine_graph: ["wowok-machine"],
+    get_guard_graph: ["wowok-guard"],
+    plan_object_edit: ["wowok-machine", "wowok-guard", "wowok-auditor"],
+    apply_object_edit: ["wowok-safety"],
+    patch_machine_nodes: ["wowok-machine"],
+    patch_guard_tree: ["wowok-guard"],
+};
+export function getSkillsHintForOnchain(operationType, data) {
+    const skills = SKILLS_BY_OPERATION_TYPE[operationType];
+    if (!skills || skills.length === 0)
+        return undefined;
+    const isPublish = data?.publish === true;
+    const hasOrderAllocators = !!data?.order_allocators;
+    const isComplex = isPublish || hasOrderAllocators;
+    const prefix = isComplex
+        ? "SKILLS RECOMMENDED (complex operation — skills provide business-semantic guidance):"
+        : "SKILLS RECOMMENDED (optional — skills provide deeper guidance):";
+    return `${prefix} ${skills.join(", ")}. ` +
+        `skills focus on business intent → object parameter translation; ` +
+        `MCP handles object structure and on-chain execution. ` +
+        `If skills are installed, consult them BEFORE this call for design rationale. ` +
+        `If not installed, MCP executes independently — this hint is informational only.`;
+}
+export function getSkillsHintForProject(action) {
+    const skills = SKILLS_BY_PROJECT_ACTION[action];
+    if (!skills || skills.length === 0)
+        return undefined;
+    return `SKILLS RECOMMENDED (optional — skills provide deeper guidance): ${skills.join(", ")}. ` +
+        `skills focus on business intent → object parameter translation; ` +
+        `MCP handles project structure and evaluation. ` +
+        `If skills are installed, consult them for design/planning rationale. ` +
+        `If not installed, MCP executes independently — this hint is informational only.`;
+}

package/dist/schema-query/index.d.ts

@@ -1,3 +1,4 @@
+export declare const EXAMPLES_DIR: string;
 export interface SchemaInfo {
     name: string;
     title: string;
@@ -6,13 +7,24 @@ export interface SchemaInfo {
     outputPath?: string;
 }
 export interface SchemaQueryRequest {
-    action: "list" | "get" | "search" | "list_operations" | "get_output" | "get_guard_templates" | "get_field";
+    action: "list" | "get" | "search" | "list_operations" | "get_output" | "get_guard_templates" | "get_field" | "search_examples";
     name?: string;
     query?: string;
     field_path?: string;
     template?: string;
     output_file?: string;
 }
+export interface ExampleSearchResult {
+    file: string;
+    title: string;
+    description: string;
+    tags: string[];
+    industry: string;
+    operation_type: string;
+    verified: boolean;
+    score: number;
+    matched_fields: string[];
+}
 export interface SchemaQueryResponse {
     [key: string]: unknown;
     success: boolean;
@@ -31,6 +43,7 @@ export declare function listSchemas(): SchemaInfo[];
 export declare function getSchema(name: string): any | null;
 export declare function getOutputSchema(name: string): any | null;
 export declare function getGuardTemplates(templateName?: string): any | null;
+export declare function searchExamples(query: string): ExampleSearchResult[];
 export declare function getSchemaField(name: string, fieldPath: string): any | null;
 export declare function searchSchemas(query: string): SchemaInfo[];
 export declare function listOperations(): SchemaInfo[];

package/dist/schema-query/index.js

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync } from "fs";
 import { resolve, join, dirname } from "path";
 import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
@@ -9,6 +9,11 @@ const GUARD_TEMPLATES_PATH_DIST = resolve(__dirname, "../../dist/schemas/guard-t
 const GUARD_TEMPLATES_PATH = existsSync(GUARD_TEMPLATES_PATH_SCRIPTS)
     ? GUARD_TEMPLATES_PATH_SCRIPTS
     : GUARD_TEMPLATES_PATH_DIST;
+const EXAMPLES_DIR_SCRIPTS = resolve(__dirname, "../../scripts/examples");
+const EXAMPLES_DIR_DIST = resolve(__dirname, "../examples");
+export const EXAMPLES_DIR = existsSync(EXAMPLES_DIR_SCRIPTS)
+    ? EXAMPLES_DIR_SCRIPTS
+    : EXAMPLES_DIR_DIST;
 const WORKSPACE_TMP_DIR = resolve(process.cwd(), ".trae", "tmp");
 export function areSchemasAvailable() {
     return existsSync(SCHEMAS_DIR) && existsSync(join(SCHEMAS_DIR, "index.json"));
@@ -96,6 +101,75 @@ export function getGuardTemplates(templateName) {
         return null;
     }
 }
+export function searchExamples(query) {
+    if (!existsSync(EXAMPLES_DIR)) {
+        return [];
+    }
+    let files;
+    try {
+        files = readdirSync(EXAMPLES_DIR);
+    }
+    catch {
+        return [];
+    }
+    const lowerQuery = query.toLowerCase().trim();
+    if (!lowerQuery) {
+        return [];
+    }
+    const results = [];
+    for (const file of files) {
+        if (!file.endsWith(".json"))
+            continue;
+        const filePath = join(EXAMPLES_DIR, file);
+        try {
+            const content = readFileSync(filePath, "utf-8");
+            const example = JSON.parse(content);
+            const title = String(example.title ?? "");
+            const description = String(example.description ?? "");
+            const tags = Array.isArray(example.tags) ? example.tags.map((t) => String(t)) : [];
+            const operationType = String(example.operation_type ?? "");
+            const industry = String(example.industry ?? "");
+            const matchedFields = [];
+            if (title.toLowerCase().includes(lowerQuery)) {
+                matchedFields.push("title");
+            }
+            if (description.toLowerCase().includes(lowerQuery)) {
+                matchedFields.push("description");
+            }
+            if (tags.some((t) => t.toLowerCase() === lowerQuery)) {
+                matchedFields.push("tags");
+            }
+            if (operationType && operationType.toLowerCase() === lowerQuery) {
+                matchedFields.push("operation_type");
+            }
+            if (industry && industry.toLowerCase() === lowerQuery) {
+                matchedFields.push("industry");
+            }
+            if (matchedFields.length > 0) {
+                results.push({
+                    file,
+                    title,
+                    description,
+                    tags,
+                    industry,
+                    operation_type: operationType,
+                    verified: example.verified === true,
+                    score: matchedFields.length,
+                    matched_fields: matchedFields,
+                });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    results.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return a.file.localeCompare(b.file);
+    });
+    return results;
+}
 export function getSchemaField(name, fieldPath) {
     const schema = getSchema(name);
     if (!schema)
@@ -267,6 +341,34 @@ export function processSchemaQuery(request) {
                 : `Retrieved ${Array.isArray(templates.templates) ? templates.templates.length : 0} Guard templates`,
         };
     }
+    if (action === "search_examples") {
+        if (!query) {
+            return {
+                success: false,
+                action,
+                data: null,
+                message: "Search query is required for 'search_examples' action",
+                suggestions: [
+                    "Provide a 'query' string (e.g. 'rental', 'guard', 'service', 'machine')",
+                    "Searchable fields: title, description, tags, operation_type, industry",
+                ],
+            };
+        }
+        const results = searchExamples(query);
+        return {
+            success: true,
+            action,
+            data: results,
+            message: `Found ${results.length} example(s) matching '${query}'`,
+            suggestions: results.length === 0
+                ? [
+                    "Try broader terms like 'service', 'machine', 'guard', 'permission'",
+                    "Try an industry name: 'rental', 'retail', 'general'",
+                    "Use 'get' action with a schema name to see the full JSON Schema",
+                ]
+                : undefined,
+        };
+    }
     if (!areSchemasAvailable()) {
         return {
             success: false,
@@ -448,7 +550,7 @@ export function processSchemaQuery(request) {
                 action,
                 data: null,
                 message: `Unknown action: ${action}`,
-                suggestions: ["Use 'list', 'get', 'get_field', 'get_output', 'search', 'list_operations', or 'get_guard_templates'"],
+                suggestions: ["Use 'list', 'get', 'get_field', 'get_output', 'search', 'list_operations', 'get_guard_templates', or 'search_examples'"],
             };
     }
 }

package/dist/schemas/account_operation.schema.json

@@ -236,7 +236,7 @@
         }
       },
       "additionalProperties": false,
-      "description": "Account operations. Parameters MUST be wrapped in the operation type property (e.g. {transfer: {...}}, NOT {amount: ...}). Unwrapped parameters are rejected."
+      "description": "Account operations (mutations only: gen/faucet/suspend/resume/rename/swap_name/transfer/get/signData/messenger). Parameters MUST be wrapped in the operation type property (e.g. {transfer: {...}}, NOT {amount: ...}). Unwrapped parameters are rejected. TO LIST ALL ACCOUNTS: use the query_toolkit tool with query_type='account_list' (returns name, address, suspended status, messenger status for all local accounts). This separation follows CQRS: account_operation = mutations, query_toolkit = queries. Common workflow after MCP restart: (1) query_toolkit query_type='account_list' to see all accounts, (2) account_operation with the appropriate mutation."
     }
   }
 }

package/dist/schemas/index.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "WoWok MCP Schema Index",
   "description": "Index of all available JSON schemas for WoWok MCP tools",
-  "generatedAt": "2026-07-26T22:55:28.022Z",
+  "generatedAt": "2026-07-29T00:14:19.691Z",
   "tools": [
     {
       "name": "onchain_operations",