@wowok/agent-mcp 2.6.3 → 2.6.6

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/skills-recommendation.js

@@ -47,6 +47,7 @@ const SKILLS_BY_PROJECT_ACTION = {
     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];

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

@@ -1,3 +1,4 @@
+import { type TemplateObjectType } from "../knowledge/template-registry.js";
 export declare const EXAMPLES_DIR: string;
 export interface SchemaInfo {
     name: string;
@@ -7,11 +8,13 @@ export interface SchemaInfo {
     outputPath?: string;
 }
 export interface SchemaQueryRequest {
-    action: "list" | "get" | "search" | "list_operations" | "get_output" | "get_guard_templates" | "get_field" | "search_examples";
+    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 {

package/dist/schema-query/index.js

@@ -1,6 +1,10 @@
 import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync } from "fs";
 import { resolve, join, dirname } from "path";
 import { fileURLToPath } from "url";
+import { TOOLS_REFERENCE, getToolReference, searchToolReference, getToolSequence, } from "../knowledge/tools-reference.js";
+import { GUARD_DESIGN_PATTERNS, getGuardDesignPattern, GUARD_DESIGN_PATTERNS_VERSION, } from "../knowledge/guard-design-patterns.js";
+import { OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_TYPE_CLASSIFICATION, OPERATION_CLASS_META, NAMING_CONVENTIONS, SAFETY_RULES_VERSION, } from "../knowledge/safety-rules.js";
+import { listTemplates as listRegistryTemplates, getTemplateDetail, instantiateTemplate, getTemplateCounts, TEMPLATE_OBJECT_TYPES, } from "../knowledge/template-registry.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const SCHEMAS_DIR = resolve(__dirname, "../../dist/schemas");
@@ -302,7 +306,7 @@ function writeResponseToFile(data, preferredPath) {
     }
 }
 export function processSchemaQuery(request) {
-    const { action, name, query, field_path, template, output_file } = request;
+    const { action, name, query, field_path, template, output_file, object_type, params } = request;
     if (action === "get_guard_templates") {
         const templates = getGuardTemplates(template);
         if (!templates) {
@@ -341,6 +345,134 @@ export function processSchemaQuery(request) {
                 : `Retrieved ${Array.isArray(templates.templates) ? templates.templates.length : 0} Guard templates`,
         };
     }
+    if (action === "get_templates") {
+        if (!template) {
+            const metas = listRegistryTemplates(object_type);
+            const counts = getTemplateCounts();
+            const data = {
+                total: metas.length,
+                filter: object_type ?? null,
+                counts_by_object_type: counts,
+                templates: metas,
+            };
+            if (output_file) {
+                const filePath = writeResponseToFile(data, output_file);
+                if (filePath) {
+                    return {
+                        success: true,
+                        action,
+                        data: null,
+                        message: `${metas.length} templates written to file: ${filePath}`,
+                        output_file_path: filePath,
+                        suggestions: [`Use Read tool to open ${filePath}`],
+                    };
+                }
+            }
+            return {
+                success: true,
+                action,
+                data,
+                message: `${metas.length} template(s)${object_type ? ` for object_type='${object_type}'` : ""} ` +
+                    `(total registry: ${Object.values(counts).reduce((a, b) => a + b, 0)} across ${TEMPLATE_OBJECT_TYPES.length} object types). ` +
+                    `Provide 'template' (id) for full detail; add 'params' (JSON string) to instantiate.`,
+            };
+        }
+        if (!params) {
+            const detail = getTemplateDetail(template);
+            if (!detail) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: `Template '${template}' not found in the unified registry.`,
+                    suggestions: [
+                        "Omit 'template' to list all template metadata (id + object_type + parameters).",
+                        `Filter by object_type: ${TEMPLATE_OBJECT_TYPES.join(", ")}`,
+                    ],
+                };
+            }
+            if (output_file) {
+                const filePath = writeResponseToFile(detail, output_file);
+                if (filePath) {
+                    return {
+                        success: true,
+                        action,
+                        data: null,
+                        message: `Template '${template}' detail written to file: ${filePath}`,
+                        output_file_path: filePath,
+                        suggestions: [`Use Read tool to open ${filePath}`],
+                    };
+                }
+            }
+            return {
+                success: true,
+                action,
+                data: detail,
+                message: `Template '${template}' (${detail.object_type}, ${detail.instantiable ? "instantiable" : "guidance-only"}). ` +
+                    `To instantiate, call again with 'params' = JSON object of the declared parameters.`,
+            };
+        }
+        let parsedParams;
+        try {
+            const parsed = JSON.parse(params);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: `'params' must be a JSON object (e.g. '{"key":"value"}'), got ${Array.isArray(parsed) ? "array" : typeof parsed}.`,
+                };
+            }
+            parsedParams = parsed;
+        }
+        catch (e) {
+            return {
+                success: false,
+                action,
+                data: null,
+                message: `Failed to parse 'params' as JSON: ${e instanceof Error ? e.message : String(e)}`,
+                suggestions: ["Example: params='{\"whitelist\":[\"0xabc...\"]}'"],
+            };
+        }
+        const result = instantiateTemplate(template, parsedParams);
+        if (!result.ok) {
+            return {
+                success: false,
+                action,
+                data: result.guidance !== undefined ? { guidance: result.guidance } : null,
+                message: `Instantiation failed for '${template}': ${result.error}`,
+                suggestions: result.missing_params
+                    ? [`Missing required params: ${result.missing_params.join(", ")}`, "Call with 'template' only (no 'params') to see full parameter declarations."]
+                    : ["Call with 'template' only (no 'params') to see full parameter declarations."],
+            };
+        }
+        const data = {
+            object_type: result.object_type,
+            template_id: result.template_id,
+            body: result.body,
+            ...(result.notes ? { notes: result.notes } : {}),
+        };
+        if (output_file) {
+            const filePath = writeResponseToFile(data, output_file);
+            if (filePath) {
+                return {
+                    success: true,
+                    action,
+                    data: null,
+                    message: `Instantiated template '${template}' written to file: ${filePath}`,
+                    output_file_path: filePath,
+                    suggestions: [`Use Read tool to open ${filePath}`],
+                };
+            }
+        }
+        return {
+            success: true,
+            action,
+            data,
+            message: `Instantiated '${template}' (${result.object_type}). ` +
+                `Review the body against the onchain_operations schema before submitting.`,
+        };
+    }
     if (action === "search_examples") {
         if (!query) {
             return {
@@ -369,6 +501,128 @@ export function processSchemaQuery(request) {
                 : undefined,
         };
     }
+    if (action === "get_tool_reference") {
+        if (name) {
+            const entry = getToolReference(name);
+            if (!entry) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: `Tool '${name}' not found in the tool reference.`,
+                    suggestions: [
+                        "Omit 'name' to list all tools.",
+                        `Available tools: ${TOOLS_REFERENCE.map((t) => t.name).join(", ")}`,
+                    ],
+                };
+            }
+            const sequence = getToolSequence(name);
+            return {
+                success: true,
+                action,
+                data: { tool: entry, call_sequence: sequence ?? null },
+                message: `Retrieved tool reference: ${name}`,
+            };
+        }
+        if (query) {
+            const matches = searchToolReference(query);
+            return {
+                success: true,
+                action,
+                data: { tools: matches, count: matches.length },
+                message: `Found ${matches.length} tool(s) matching '${query}'`,
+                suggestions: matches.length === 0
+                    ? ["Try a broader keyword (e.g. 'onchain', 'guard', 'schema'), or omit 'query' to list all tools."]
+                    : undefined,
+            };
+        }
+        const catalog = TOOLS_REFERENCE.map((t) => ({
+            name: t.name,
+            summary: t.summary,
+            actions: t.actions ?? [],
+            notes: t.notes ?? [],
+        }));
+        return {
+            success: true,
+            action,
+            data: { tools: catalog, count: catalog.length },
+            message: `Retrieved reference for ${catalog.length} MCP tools. Pass name='<tool>' for full detail (params, prerequisites, follow-ups).`,
+        };
+    }
+    if (action === "get_guard_design_patterns") {
+        if (name) {
+            const pattern = getGuardDesignPattern(name);
+            if (!pattern) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: `Guard design pattern '${name}' not found.`,
+                    suggestions: [
+                        "Omit 'name' to list the full catalog.",
+                        `Available pattern ids: ${GUARD_DESIGN_PATTERNS.map((p) => p.id).join(", ")}`,
+                    ],
+                };
+            }
+            return {
+                success: true,
+                action,
+                data: { pattern },
+                message: `Retrieved Guard design pattern: ${name}`,
+            };
+        }
+        if (query) {
+            const byHost = GUARD_DESIGN_PATTERNS.filter((p) => p.host === query);
+            const matches = byHost.length > 0
+                ? byHost
+                : GUARD_DESIGN_PATTERNS.filter((p) => p.business_requirement.toLowerCase().includes(query.toLowerCase()) ||
+                    p.logic_summary.toLowerCase().includes(query.toLowerCase()));
+            return {
+                success: true,
+                action,
+                data: { patterns: matches, count: matches.length, filtered_by: byHost.length > 0 ? "host" : "keyword" },
+                message: `Found ${matches.length} Guard design pattern(s) matching '${query}'`,
+                suggestions: matches.length === 0
+                    ? ["Filter by host: service_buy_guard, service_allocator_guard, machine_forward, progress_submission, reward_claim, repository_write, arbitration_usage, arbitration_voting, gen_passport"]
+                    : undefined,
+            };
+        }
+        const catalog = GUARD_DESIGN_PATTERNS.map((p) => ({
+            id: p.id,
+            business_requirement: p.business_requirement,
+            host: p.host,
+            data_source: p.data_source,
+            verifier_level: p.verifier_level,
+            logic_summary: p.logic_summary,
+            key_queries: p.key_queries,
+            notes: p.notes ?? [],
+        }));
+        return {
+            success: true,
+            action,
+            data: { patterns: catalog, count: catalog.length, version: GUARD_DESIGN_PATTERNS_VERSION },
+            message: `Retrieved ${catalog.length} Guard design patterns. Pass name='<pattern_id>' for full detail (witness types, mitigated risks, industries).`,
+        };
+    }
+    if (action === "get_safety_rules") {
+        return {
+            success: true,
+            action,
+            data: {
+                version: SAFETY_RULES_VERSION,
+                object_reuse_rules: OBJECT_REUSE_RULES,
+                create_vs_modify_pattern: CREATE_VS_MODIFY_PATTERN,
+                immutability_rules: IMMUTABILITY_RULES,
+                operation_type_classification: OPERATION_TYPE_CLASSIFICATION,
+                operation_class_meta: OPERATION_CLASS_META,
+                naming_conventions: NAMING_CONVENTIONS,
+            },
+            message: "Retrieved safety rule tables (reuse / immutability / operation classification / naming). " +
+                "Key points: prefer REUSING existing objects (string reference = reuse, object shape = create); " +
+                "Machine publish locks nodes/pairs/forwards, Service publish locks machine/order_allocators/arbitrations (sales stays mutable); " +
+                "Guard is CREATE-only immutable; on-chain writes require explicit user confirmation.",
+        };
+    }
     if (!areSchemasAvailable()) {
         return {
             success: false,

package/dist/schemas/bridge_operation.schema.json

@@ -108,6 +108,7 @@
                 },
                 "schema_strict_mode": {
                   "type": "boolean",
+                  "default": false,
                   "description": "When true, schema incompatibility returns an error instead of a warning. Default: false (warn mode)."
                 },
                 "dry_run": {
@@ -289,7 +290,7 @@
                     "mainnet"
                   ],
                   "default": "mainnet",
-                  "description": "Target chain (defaults to Ethereum mainnet)"
+                  "description": "Target chain (defaults to Ethereum mainnet when omitted — EvmChainSchema carries .default(\"mainnet\"))"
                 }
               },
               "required": [
@@ -319,6 +320,7 @@
               "properties": {
                 "network": {
                   "$ref": "#/definitions/bridge_operation/anyOf/4/properties/data/properties/network",
+                  "default": "mainnet",
                   "description": "Specific chain; if omitted, queries all supported chains"
                 },
                 "tokens": {
@@ -364,7 +366,7 @@
               "type": "object",
               "properties": {
                 "network": {
-                  "$ref": "#/definitions/bridge_operation/anyOf/4/properties/data/properties/network",
+                  "$ref": "#/definitions/bridge_operation/anyOf/5/properties/data/properties/network",
                   "description": "Specific chain; if omitted, returns token lists for all supported chains"
                 }
               },
@@ -485,7 +487,8 @@
                     },
                     "network": {
                       "$ref": "#/definitions/bridge_operation/anyOf/4/properties/data/properties/network",
-                      "description": "Target chain (defaults to Ethereum mainnet)"
+                      "default": "mainnet",
+                      "description": "Target chain (defaults to Ethereum mainnet when omitted — EvmChainSchema carries .default(\"mainnet\"))"
                     }
                   },
                   "required": [
@@ -504,7 +507,8 @@
                     },
                     "network": {
                       "$ref": "#/definitions/bridge_operation/anyOf/4/properties/data/properties/network",
-                      "description": "Target chain (defaults to Ethereum mainnet)"
+                      "default": "mainnet",
+                      "description": "Target chain (defaults to Ethereum mainnet when omitted — EvmChainSchema carries .default(\"mainnet\"))"
                     },
                     "rpcUrls": {
                       "type": "array",
@@ -533,7 +537,8 @@
                     },
                     "network": {
                       "$ref": "#/definitions/bridge_operation/anyOf/4/properties/data/properties/network",
-                      "description": "Target chain (defaults to Ethereum mainnet)"
+                      "default": "mainnet",
+                      "description": "Target chain (defaults to Ethereum mainnet when omitted — EvmChainSchema carries .default(\"mainnet\"))"
                     },
                     "rpcUrls": {
                       "type": "array",
@@ -562,7 +567,8 @@
                     },
                     "network": {
                       "$ref": "#/definitions/bridge_operation/anyOf/4/properties/data/properties/network",
-                      "description": "Target chain (defaults to Ethereum mainnet)"
+                      "default": "mainnet",
+                      "description": "Target chain (defaults to Ethereum mainnet when omitted — EvmChainSchema carries .default(\"mainnet\"))"
                     },
                     "rpcUrls": {
                       "type": "array",
@@ -591,7 +597,8 @@
                     },
                     "network": {
                       "$ref": "#/definitions/bridge_operation/anyOf/4/properties/data/properties/network",
-                      "description": "Target chain (defaults to Ethereum mainnet)"
+                      "default": "mainnet",
+                      "description": "Target chain (defaults to Ethereum mainnet when omitted — EvmChainSchema carries .default(\"mainnet\"))"
                     },
                     "rpcUrls": {
                       "type": "array",

package/dist/schemas/guard2file.schema.json

@@ -22,6 +22,7 @@
             "json",
             "markdown"
           ],
+          "default": "json",
           "description": "Output format: 'json' (default) or 'markdown'"
         },
         "env": {
@@ -77,6 +78,7 @@
             },
             "schema_strict_mode": {
               "type": "boolean",
+              "default": false,
               "description": "When true, schema incompatibility returns an error instead of a warning. Default: false (warn mode)."
             },
             "dry_run": {