@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/schema/trust/index.js

@@ -1,5 +1,94 @@
 import { z } from "zod";
 import { NameOrAddressSchema } from "../common/index.js";
+const RiskCheckOutputSchema = z.object({
+    id: z.string().describe("Check identifier."),
+    dimension: z
+        .enum(["workflow", "fund", "trust", "behavior"])
+        .describe("Dimension this check belongs to."),
+    description: z.string().describe("Check description."),
+    weight: z.number().describe("Check weight within its dimension (percentage)."),
+    passed: z.boolean().describe("Whether the check passed."),
+    advice: z.string().optional().describe("Advice when the check failed."),
+});
+const ReminderOutputSchema = z.object({
+    id: z.string().describe("Reminder rule identifier."),
+    stage: z
+        .enum(["browse", "evaluate", "preorder", "in_progress", "complete", "after_sale"])
+        .describe("Workflow stage this reminder belongs to."),
+    priority: z
+        .enum(["required", "recommended", "info", "reminder"])
+        .describe("Priority: required = blocking, recommended = strongly suggested."),
+    message: z.string().describe("Human-readable reminder message."),
+    action: z.string().optional().describe("Suggested follow-up action, if any."),
+});
+const IndustryEnumSchema = z.enum([
+    "freelance", "rental", "education", "travel", "subscription", "retail",
+]);
+const PreorderPreferencesInputSchema = z
+    .object({
+    price_sensitivity: z.enum(["low", "medium", "high"]).optional(),
+    budget_range: z
+        .object({
+        min: z.union([z.string(), z.number()]).describe("Budget lower bound (smallest token unit)."),
+        max: z.union([z.string(), z.number()]).describe("Budget upper bound (smallest token unit)."),
+    })
+        .strict()
+        .optional(),
+    value_orientation: z.enum(["quality", "balanced", "budget"]).optional(),
+    discount_sensitivity: z.number().min(0).max(1).optional(),
+    delivery_speed_priority: z.enum(["urgent", "normal", "flexible"]).optional(),
+    max_acceptable_cycle: z.number().nonnegative().describe("Max acceptable delivery cycle (days).").optional(),
+    response_time_expectation: z.number().nonnegative().describe("Expected merchant response time (hours).").optional(),
+    merchant_preference: z.enum(["established", "emerging", "neutral"]).optional(),
+    min_order_history: z.number().int().nonnegative().optional(),
+    bargain_hunting: z.number().min(0).max(1).optional(),
+    reward_seeking: z.boolean().optional(),
+    referral_participation: z.boolean().optional(),
+    communication_style: z.enum(["formal", "casual", "friendly"]).optional(),
+    transparency_demand: z.number().min(0).max(1).optional(),
+    after_sales_expectation: z.enum(["full", "basic", "minimal"]).optional(),
+    risk_appetite: z.enum(["conservative", "balanced", "aggressive"]).optional(),
+    min_trust_score: z.number().min(0).max(100).optional(),
+    require_arbitration: z.boolean().optional(),
+    require_compensation_fund: z.boolean().optional(),
+    preferred_industries: z.array(z.string()).optional(),
+    preferred_tokens: z.array(z.string()).optional(),
+    preferred_merchants: z.array(z.string()).optional(),
+})
+    .strict();
+const UserMetricInputSchema = z
+    .object({
+    name: z.string().describe("Stable metric identifier (e.g. 'merchant_tenure_days')."),
+    label: z.string().describe("Human-readable label shown to the user."),
+    evaluator: z
+        .enum(["threshold", "ratio", "boolean", "presence", "regex_match", "custom_query"])
+        .describe("How the metric is evaluated against the puzzle context."),
+    params: z
+        .object({
+        path: z.string().optional().describe("JSON path in the raw data context (e.g. 'service.name')."),
+        threshold: z.union([z.string(), z.number()]).optional().describe("Threshold value (threshold/presence evaluators)."),
+        invert: z.boolean().optional().describe("true: pass when value <= threshold."),
+        min: z.number().optional().describe("Min ratio (ratio evaluator)."),
+        max: z.number().optional().describe("Max ratio (ratio evaluator)."),
+        pattern: z.string().optional().describe("Regex pattern (regex_match evaluator)."),
+        query_key: z.string().optional().describe("Custom query identifier (custom_query evaluator)."),
+    })
+        .strict(),
+    weight: z.number().min(0).max(1).describe("Relative weight vs other user metrics (0-1)."),
+    advice_on_fail: z.string().optional(),
+    advice_on_pass: z.string().optional(),
+})
+    .strict();
+const UserMetricsInputSchema = z
+    .object({
+    metrics: z.array(UserMetricInputSchema).min(1).describe("User-defined scoring factors."),
+    adjustment_cap: z
+        .number()
+        .positive()
+        .optional()
+        .describe("Global cap for the composite confidence adjustment (default ±10 points)."),
+})
+    .strict();
 export const TrustScoreInputSchema = z
     .object({
     service: NameOrAddressSchema.describe("Service object ID or local_mark name to evaluate. " +
@@ -16,7 +105,13 @@ export const TrustScoreInputSchema = z
         .describe("InfoPuzzle collection depth. " +
         "browse: only Service basics + trust score; " +
         "evaluate (default): + workflow/fund/trust dimensions risk assessment; " +
-        "preorder: + merchant behavior + market context (most thorough)."),
+        "preorder: + full preorder advice (confidence, game strategies, preference match, industry risks, blocking reminders)."),
+    industry: IndustryEnumSchema.optional().describe("Explicit industry override for industry-specific risk checks and needs matrix. " +
+        "If omitted at depth=preorder, the industry is inferred from the puzzle."),
+    preferences: PreorderPreferencesInputSchema.optional().describe("Optional user preference overrides (partial; merged over profile-derived defaults). " +
+        "Only used at depth=preorder for preference matching and pref-aware strategies."),
+    user_metrics: UserMetricsInputSchema.optional().describe("Optional user-controllable scoring factors (评分体系用户可控). " +
+        "Evaluated at depth=preorder; the composite adjustment (±cap) nudges the order confidence score."),
     network: z
         .string()
         .optional()
@@ -25,6 +120,14 @@ export const TrustScoreInputSchema = z
         .boolean()
         .optional()
         .describe("Skip object cache and force a fresh on-chain query."),
+    compare_with: z
+        .array(z.string())
+        .min(1)
+        .max(9)
+        .optional()
+        .describe("Optional candidate Service addresses/LocalMark names (1-9) for deterministic multi-service comparison. " +
+        "Only used at depth=preorder. The SAME preferences/user_metrics/industry are applied uniformly to all " +
+        "candidates; output gains a `comparison` block with per-metric bests (NO overall ranking — the buyer decides)."),
 })
     .strict();
 export const TrustScoreOutputSchema = z
@@ -83,16 +186,7 @@ export const TrustScoreOutputSchema = z
                     .describe("Risk dimension name."),
                 score: z.number().describe("Dimension score achieved."),
                 max_score: z.number().describe("Dimension max possible score."),
-                checks: z.array(z.object({
-                    id: z.string().describe("Check identifier."),
-                    dimension: z
-                        .enum(["workflow", "fund", "trust", "behavior"])
-                        .describe("Dimension this check belongs to."),
-                    description: z.string().describe("Check description."),
-                    weight: z.number().describe("Check weight within its dimension (percentage)."),
-                    passed: z.boolean().describe("Whether the check passed."),
-                    advice: z.string().optional().describe("Advice when the check failed."),
-                })).describe("Individual risk checks within this dimension."),
+                checks: z.array(RiskCheckOutputSchema).describe("Individual risk checks within this dimension."),
             }))
                 .describe("4-dimension breakdown: workflow / fund / trust / behavior."),
         })
@@ -106,8 +200,115 @@ export const TrustScoreOutputSchema = z
         })
             .optional()
             .describe("InfoPuzzle summary — present only when depth >= 'evaluate'."),
+        preorder_advice: z
+            .object({
+            confidence: z
+                .object({
+                score: z.number().min(0).max(100).describe("Composite order confidence (0-100, higher = safer to order)."),
+                base: z.number().describe("Base confidence = 100 - risk.total."),
+                user_adjustment: z.number().describe("User-controllable adjustment from user_metrics (±cap)."),
+                preference_nudge: z.number().describe("Preference-match nudge (±5, only when preferences were provided)."),
+                explanation: z.string().describe("Transparent breakdown of the confidence components."),
+            })
+                .describe("ConfidenceScore — user-controllable composite order confidence."),
+            industry: IndustryEnumSchema.optional().describe("Industry used for the industry-specific risk checks (explicit input or inferred)."),
+            strategies: z
+                .array(z.object({
+                scenario: z
+                    .enum([
+                    "info_asymmetry", "fund_safety", "refund_dispute", "arbitration_fairness",
+                    "pricing", "delivery_sla", "quality_verification", "after_sales",
+                ])
+                    .describe("Game scenario detected from the puzzle."),
+                merchant_tactic: z.string().describe("Merchant's potential tactic in this scenario."),
+                user_strategy: z.string().describe("Recommended user-side strategy (protection/mitigation)."),
+                nash_equilibrium: z.string().describe("Win-win equilibrium the strategy pushes toward."),
+                confidence: z.number().min(0).max(1).describe("Strategy confidence (0-1)."),
+                fallback: z.string().optional().describe("Alternative when the user rejects the main strategy."),
+                rationale: z.string().describe("Trigger-condition explanation from puzzle evidence."),
+            }))
+                .describe("Top merchant-vs-user game strategies (user side, max 3)."),
+            preference_match: z
+                .object({
+                score: z.number().min(0).max(100).describe("Preference match score (0-100)."),
+                matches: z.array(z.string()).describe("Aspects matching the user's preferences."),
+                mismatches: z.array(z.string()).describe("Aspects mismatching the user's preferences."),
+                warnings: z.array(z.string()).describe("Match warnings (e.g. budget stretch)."),
+            })
+                .optional()
+                .describe("PreferenceMatchResult — present when preferences (input or profile) were available."),
+            preference_issues: z
+                .array(z.string())
+                .optional()
+                .describe("Validation issues found in the merged preferences (e.g. budget min > max)."),
+            industry_risks: z
+                .object({
+                score_adjustment: z.number().describe("Industry risk adjustment applied to the base risk score (-10 to +10)."),
+                summary: z.string().describe("Industry risk assessment summary."),
+                checks: z.array(RiskCheckOutputSchema).describe("Industry-specific risk checks."),
+                unmet_needs: z
+                    .array(z.object({
+                    id: z.string().describe("Need identifier."),
+                    tier: z.enum(["common", "personalized", "advanced"]).describe("Need tier."),
+                    description: z.string().describe("Need description."),
+                    advice: z.string().optional().describe("Advice for fulfilling the need."),
+                }))
+                    .describe("Industry needs not satisfied by this Service."),
+            })
+                .optional()
+                .describe("IndustryRiskResult — industry pain-point checks (needs met / risks triggered)."),
+            reminders: z
+                .array(ReminderOutputSchema)
+                .describe("Transaction-safety reminders at the preorder stage (sorted, capped)."),
+            blocking_reminders: z
+                .array(ReminderOutputSchema)
+                .describe("Blocking (priority=required) reminders — resolve these before ordering."),
+            summary: z.string().describe("AI-ready paragraph summarizing the whole preorder report."),
+        })
+            .optional()
+            .describe("PreorderAdvice (GLM6/94 §3) — present only when depth = 'preorder'. " +
+            "AI presents evidence and options; the USER decides whether to order."),
+        comparison: z
+            .object({
+            rows: z
+                .array(z
+                .object({
+                service_id: z.string(),
+                service_name: z.string(),
+                error: z.string().optional().describe("Per-service evaluation failure (row excluded from best-per-metric)."),
+                industry: IndustryEnumSchema.optional(),
+                confidence: z.number().optional().describe("Order confidence 0-100 (higher = safer)."),
+                risk_total: z.number().optional().describe("Risk score 0-100 (lower = safer)."),
+                risk_level: z.string().optional(),
+                trust_score: z.number().optional().describe("Trust score 0-100 (higher = more trustworthy)."),
+                trust_level: z.string().optional(),
+                preference_match: z.number().optional().describe("Preference match 0-100 (higher = better fit)."),
+                reputation_like_ratio: z.number().optional().describe("likes/(likes+dislikes); 1 when no votes."),
+                reputation_votes: z.number().optional(),
+                red_flags_count: z.number().optional(),
+                blocking_reminders_count: z.number().optional(),
+                info_gaps_count: z.number().optional(),
+            })
+                .strict())
+                .describe("One row per evaluated service (primary first, then compare_with candidates)."),
+            best_per_metric: z
+                .record(z.string(), z.array(z.string()))
+                .describe("metric name → service_ids with the best value (ties all listed). Per-metric ONLY."),
+            evaluated_metrics: z
+                .array(z.string())
+                .describe("Metrics actually compared (skipped when fewer than 2 rows have data)."),
+            note: z
+                .string()
+                .describe("Neutrality note: no overall ranking; metric weights belong to the buyer."),
+        })
+            .strict()
+            .optional()
+            .describe("Deterministic multi-service comparison (GLM6/94 L6) — present only when depth='preorder' " +
+            "and compare_with is provided. Per-metric bests ONLY, no overall ranking — the buyer decides."),
     })
         .describe("Trust score result. Contains: trust_score (ServiceTrustScore), " +
         "risk_score (RiskScore, when depth >= evaluate), info_puzzle summary, " +
+        "preorder_advice (PreorderAdvice, when depth = preorder), " +
+        "comparison (PreorderComparison, when depth = preorder and compare_with given), " +
         "and service_basics snapshot."),
 });

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,77 @@
+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"],
+    participation_radar: ["wowok-order", "wowok-messenger"],
+};
+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,5 @@
+import { type TemplateObjectType } from "../knowledge/template-registry.js";
+export declare const EXAMPLES_DIR: string;
 export interface SchemaInfo {
     name: string;
     title: string;
@@ -6,13 +8,26 @@ 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" | "get_tool_reference" | "get_guard_design_patterns" | "get_safety_rules" | "get_templates";
     name?: string;
     query?: string;
     field_path?: string;
     template?: string;
+    object_type?: TemplateObjectType;
+    params?: 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 +46,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[];