@wowok/agent-mcp 2.6.3 → 2.6.4

package/dist/schema/project/index.js

@@ -82,6 +82,20 @@ export const ProjectOperationInputSchema = z
         "apply_object_edit",
         "patch_machine_nodes",
         "patch_guard_tree",
+        "recommend_industry",
+        "list_modes",
+        "derive_user_mode",
+        "evolve_user_mode",
+        "register_user_mode",
+        "unregister_user_mode",
+        "register_custom_metric",
+        "register_custom_constraint",
+        "list_metrics_constraints",
+        "analyze_intent",
+        "aggregate_risks",
+        "trace_substeps",
+        "merchant_guide",
+        "participation_radar",
     ])
         .describe("Action to perform. Two categories:\n" +
         "1. Project Entity + Evaluation (15, GLM6): list_projects, create_project, create_project_from_onchain, update_project, get_project_detail, add_object, remove_object, create_version, build_graph, get_graph, evaluate_project, save_evaluation, compare_projects, refresh_objects, get_object_diff. Projects are first-class entities with SQLite persistence, rigid project-object relationships, three-pathway graph construction, and a dual rule-based + LLM-assisted evaluation engine.\n" +
@@ -385,6 +399,301 @@ export const ProjectOperationInputSchema = z
         "  'set table_name <identifier> <name|none>' | 'set table_submission <identifier> <true|false>'\n" +
         "  'set root <json_node>' | 'set rely <comma_separated_guard_addresses|none>'\n" +
         "Operations are applied in order. Both patches are validated (validateMachine/validateGuard) before execution."),
+    intent: z
+        .string()
+        .max(2000)
+        .optional()
+        .describe("Business intent text for recommend_industry (e.g. 'I rent cameras to photographers " +
+        "with deposit and damage inspection'). Falls back to project_description / project_name when omitted."),
+    mode_source: z
+        .string()
+        .optional()
+        .describe("Source builtin mode name for derive_user_mode (e.g. 'freelance'). Call list_modes to see available modes."),
+    mode_name: z
+        .string()
+        .max(100)
+        .optional()
+        .describe("Mode name for derive_user_mode (new mode name), evolve_user_mode / unregister_user_mode (existing custom mode), register_user_mode (new mode name). " +
+        "Must NOT conflict with builtin mode names."),
+    mode_display_name: z
+        .string()
+        .max(200)
+        .optional()
+        .describe("Display name for derive_user_mode / register_user_mode. Defaults to mode_name."),
+    mode_changes: z
+        .record(z.unknown())
+        .optional()
+        .describe("Mode field overrides for derive_user_mode / evolve_user_mode / register_user_mode. " +
+        "For register_user_mode, REQUIRED fields: machine_shape (non-empty array of {name, role}) and key_risk (string). " +
+        "Common overrides: machine_shape (array of {name:string, role:string}), config_overrides (per-object config), " +
+        "allocator, guards, build_notes, risk_appetite. " +
+        "R-M1-11 ENFORCED: machine_shape node names must NOT contain dispute/refund/arb terms — " +
+        "disputes flow through Service.arbitrations independently of the Machine."),
+    mode_change_description: z
+        .string()
+        .max(500)
+        .optional()
+        .describe("Change description for evolve_user_mode (recorded in evolution history)."),
+    mode_bump_version: z
+        .boolean()
+        .optional()
+        .describe("Whether evolve_user_mode bumps the patch version (default true: v1.0 → v1.1)."),
+    metric_id: z.string().max(100).optional().describe("Unique metric ID for register_custom_metric (e.g. 'seasonality_risk')."),
+    metric_display_name: z.string().max(200).optional().describe("Display name for register_custom_metric."),
+    metric_description: z.string().max(1000).optional().describe("Description for register_custom_metric."),
+    metric_type: z
+        .enum(["risk", "benefit"])
+        .optional()
+        .describe("Metric type for register_custom_metric: 'risk' (negative) or 'benefit' (positive)."),
+    metric_scale: z
+        .enum(["level", "numeric", "percentage"])
+        .optional()
+        .describe("Metric scale for register_custom_metric: 'level' (high/medium/low), 'numeric', or 'percentage'."),
+    metric_weight: z
+        .number()
+        .min(0)
+        .max(10)
+        .optional()
+        .describe("Metric weight for register_custom_metric (default 1.0)."),
+    constraint_id: z.string().max(100).optional().describe("Unique constraint ID for register_custom_constraint."),
+    constraint_display_name: z.string().max(200).optional().describe("Display name for register_custom_constraint."),
+    constraint_description: z.string().max(1000).optional().describe("Description for register_custom_constraint."),
+    constraint_rule: z
+        .discriminatedUnion("type", [
+        z.object({ type: z.literal("capability_required"), capability_id: z.string() }).strict(),
+        z.object({ type: z.literal("capability_forbidden"), capability_id: z.string() }).strict(),
+        z.object({ type: z.literal("numeric_limit"), field: z.string(), max: z.number().optional(), min: z.number().optional() }).strict(),
+        z.object({ type: z.literal("condition_required"), condition: z.string(), ai_evaluated: z.literal(true) }).strict(),
+    ])
+        .optional()
+        .describe("Constraint rule for register_custom_constraint. 4 types: " +
+        "capability_required/capability_forbidden (capability_id), numeric_limit (field + max/min), " +
+        "condition_required (natural-language condition, AI-evaluated)."),
+    constraint_severity: z
+        .enum(["hard", "soft"])
+        .optional()
+        .describe("Constraint severity for register_custom_constraint: 'hard' blocks applyTemplate on violation; 'soft' only warns (default 'soft')."),
+    constraint_on_violation: z
+        .enum(["block", "warn", "log"])
+        .optional()
+        .describe("Violation action for register_custom_constraint (default 'warn')."),
+    metric_type_filter: z
+        .enum(["risk", "benefit"])
+        .optional()
+        .describe("Filter list_metrics_constraints by metric type."),
+    scope_filter: z
+        .enum(["builtin", "custom"])
+        .optional()
+        .describe("Filter list_metrics_constraints by scope (builtin or custom)."),
+    target_objects: z
+        .array(z.string())
+        .optional()
+        .describe("Optional explicit target objects for analyze_intent (entry_ids or object_type names). " +
+        "When provided, puzzle snapshots are restricted to these objects."),
+    puzzles: z
+        .record(z
+        .object({
+        puzzle: z.unknown().describe("Puzzle snapshot (opaque — pass through from analyze_intent output unchanged)."),
+        completeness: z.unknown().describe("Completeness snapshot (opaque — pass through unchanged)."),
+        missing_dimensions: z.array(z.string()).describe("Dimensions still missing for this object."),
+    })
+        .strict())
+        .optional()
+        .describe("Per-object puzzle snapshots for aggregate_risks, keyed by object_type. " +
+        "Pass the 'puzzles' field from a prior analyze_intent result UNCHANGED. " +
+        "When omitted but 'intent' is present, the handler runs analyze_intent first (C1→C2 in one call)."),
+    severity_threshold: z
+        .enum(["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"])
+        .optional()
+        .describe("Severity threshold for aggregate_risks (default 'HIGH'). Risks at or above this level block deployment (status RISK_BLOCKED)."),
+    user_confirmed_high_risks: z
+        .array(z.string())
+        .optional()
+        .describe("IDs of HIGH risks the user has already confirmed in a prior round (aggregate_risks). " +
+        "Confirmed HIGH risks no longer trigger RISK_PENDING_CONFIRM."),
+    planned_objects: z
+        .array(z
+        .object({
+        object_type: z.string().describe("Wowok object type (e.g. 'service', 'guard', 'machine')."),
+        is_new: z.boolean().describe("true when creating a NEW object; false when reusing an existing one."),
+        name: z.string().optional().describe("Planned object name (for readable messages)."),
+    })
+        .strict())
+        .optional()
+        .describe("Planned objects for aggregate_risks OBJECT_REUSE check (safety-rules). " +
+        "Flags NEW objects whose type carries an always/strongly-recommended reuse rule."),
+    planned_operations: z
+        .array(z
+        .object({
+        object_type: z.string().describe("Wowok object type (e.g. 'service', 'arbitration')."),
+        trigger: z.enum(["create", "publish"]).describe("Lifecycle trigger that locks fields."),
+        name: z.string().optional().describe("Object name (for readable messages)."),
+    })
+        .strict())
+        .optional()
+        .describe("Planned create/publish operations for aggregate_risks IMMUTABILITY check (safety-rules). " +
+        "Warns which fields become permanently locked after each operation."),
+    substeps: z
+        .array(z
+        .object({
+        step_id: z.string().describe("Substep id, format 'T<step>.<substep>' e.g. 'T1.1'."),
+        parent_step: z.string().describe("Parent step id, format 'T<step>' e.g. 'T1'."),
+        object_type: ProjectObjectTypeEnum.describe("Wowok object type this substep operates on."),
+        entry_id: z.string().describe("Puzzle entry_id this substep corresponds to."),
+        operation_type: z.string().describe("operation_type for onchain_operations."),
+        network: z.enum(["testnet", "mainnet"]).describe("Target network."),
+        input: z
+            .object({
+            data: z.record(z.unknown()).describe("Input data payload."),
+            input_refs: z.array(z.string()).describe("Upstream substep_ids this substep consumes."),
+        })
+            .strict(),
+        output: z
+            .object({
+            object_id: z.string().optional(),
+            tx_digest: z.string().optional(),
+        })
+            .catchall(z.unknown())
+            .optional()
+            .describe("Output data (filled after execution)."),
+        timestamp: z.number().describe("Execution timestamp (ms)."),
+        status: z.enum(["PENDING", "SUCCESS", "FAILED", "SKIPPED"]).describe("Execution status."),
+        failure_reason: z.string().optional().describe("Failure reason (when status='FAILED')."),
+        dependencies: z
+            .object({
+            input_refs: z.array(z.string()),
+            output_refs: z
+                .array(z
+                .object({
+                substep_id: z.string().describe("Downstream substep that consumes this output."),
+                field_path: z.string().describe("Field path produced by this substep (e.g. 'permission_address')."),
+            })
+                .strict()),
+        })
+            .strict()
+            .describe("Dependencies (input_refs + output_refs)."),
+        retry_info: z
+            .object({
+            original_step_id: z.string(),
+            retry_count: z.number(),
+            retry_reason: z.string(),
+        })
+            .strict()
+            .optional()
+            .describe("Retry info (when this substep is a retry of an earlier one)."),
+    })
+        .strict())
+        .optional()
+        .describe("Substep execution records for trace_substeps (63-spec §2.1). " +
+        "Required when action='trace_substeps'. Construct from your deployment execution trace."),
+    substep_edges: z
+        .array(z
+        .object({
+        source: z.string().describe("Source substep id."),
+        target: z.string().describe("Target substep id (depends on source)."),
+        field_path: z.string().describe("Field path flowing along this edge."),
+    })
+        .strict())
+        .optional()
+        .describe("Explicit DAG edges for trace_substeps. When omitted, edges are derived from each substep's input_refs."),
+    guide_state: z
+        .object({
+        intent_text: z.string().describe("Step 1: raw merchant business description."),
+        confirmed_industry: z.string().optional().describe("Step 2: merchant-confirmed industry id."),
+        currency: z.string().optional().describe("Step 5: payment currency (default WOW)."),
+        deliverables: z.array(z.unknown()).optional().describe("Step 4: merchant-defined deliverables (opaque passthrough)."),
+        payment_override: z.record(z.unknown()).optional().describe("Step 5: payment structure overrides (opaque passthrough)."),
+        trust_override: z.record(z.unknown()).optional().describe("Step 6: trust mechanism overrides (opaque passthrough)."),
+        adopted_module_ids: z.array(z.string()).optional().describe("Step 6: merchant-confirmed business module ids."),
+    })
+        .strict()
+        .optional()
+        .describe("Wizard state from a prior merchant_guide result. Pass back UNCHANGED on " +
+        "every subsequent call (same pattern as C1→C2 puzzles). The handler re-runs " +
+        "the pipeline deterministically and advances to the furthest reachable step."),
+    guide_confirm: z
+        .object({
+        industry: z.string().optional().describe("Step 2 confirmation: industry id (e.g. 'freelance')."),
+        currency: z.string().optional().describe("Step 5 confirmation: payment currency."),
+        deliverables: z.array(z.unknown()).optional().describe("Step 4 confirmation: deliverable definitions."),
+        payment: z.record(z.unknown()).optional().describe("Step 5 confirmation: { model, triggers, allocation } overrides."),
+        trust: z.record(z.unknown()).optional().describe("Step 6 confirmation: { refundPolicy, arbitration, escrow } overrides."),
+        adopted_module_ids: z.array(z.string()).optional().describe("Step 6 confirmation: business module ids to adopt (overrides recommendation)."),
+    })
+        .strict()
+        .optional()
+        .describe("Merchant decisions for the current wizard step. Merged over guide_state. " +
+        "Typical flow: call 1 with intent only → receive step-2 industry options → " +
+        "call 2 with guide_state + guide_confirm={industry} → receive full blueprint " +
+        "plan (steps 7-10)."),
+    radar_account: z
+        .string()
+        .optional()
+        .describe("Account to analyze — address (0x...) or LocalMark name (resolved to an address). " +
+        "Required when action='participation_radar'. The perspective (customer/operator/observer) " +
+        "is DERIVED from on-chain data (Order.builder + PermissionPerm grants) — never asserted by this field."),
+    radar_targets: z
+        .array(z
+        .object({
+        progress: z
+            .string()
+            .describe("Progress object address (0x...) or LocalMark name. The Progress carries the current node + bound Machine."),
+        order: z
+            .string()
+            .optional()
+            .describe("Order object address or LocalMark name (optional but recommended — enables order-holder detection, " +
+            "service-level compensation/reward claims, and dispute context)."),
+    })
+        .strict())
+        .min(1)
+        .max(20)
+        .optional()
+        .describe("In-flight orders to analyze (1-20). Required when action='participation_radar'. " +
+        "Each target is analyzed independently; results are aggregated into one account dashboard."),
+    radar_include_alerts: z
+        .boolean()
+        .optional()
+        .describe("Attach order-monitor alerts (progress stall / compensation fund / review & arbitration windows) " +
+        "to each per-order result. Default true."),
+    radar_monitor_thresholds: z
+        .object({
+        progress_stall_hours: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Progress stall alert threshold in HOURS. Default 0 = auto (expected_node_duration × 2)."),
+        compensation_drop_ratio: z
+            .number()
+            .min(0)
+            .max(1)
+            .optional()
+            .describe("Compensation fund drop alert ratio (0-1). Default 0.3 = alert on ≥30% drop."),
+        compensation_coverage_min: z
+            .number()
+            .min(0)
+            .max(1)
+            .optional()
+            .describe("Minimum compensation coverage ratio vs order amount (0-1). Default 1.0 = must fully cover."),
+        messenger_timeout_hours: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Messenger no-reply timeout in HOURS. Default 24."),
+        review_window_closing_days: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Review window near-closing alert threshold in DAYS. Default 3."),
+        arb_window_closing_days: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Arbitration window near-closing alert threshold in DAYS. Default 3."),
+    })
+        .strict()
+        .optional()
+        .describe("Optional per-call overrides for order-monitor alert thresholds (only used when radar_include_alerts is on). " +
+        "All fields optional; omitted fields keep defaults. Units: hours/days as marked per field."),
 })
     .strict();
 const AssembleContextResultSchema = z
@@ -480,6 +789,17 @@ const RecommendedCreationOrderItemSchema = z.object({
     reason: z.string().describe("Why this step is here, including dependencies and irreversibility notes."),
     required: z.boolean().describe("Whether this step is mandatory for a working deployment."),
 }).strict();
+const RecommendedIndustryItemSchema = z.object({
+    industry: z.string().describe("Recommended builtin industry mode name."),
+    similarity: z.number().describe("Trait similarity 0-1 (10-dim industry trait match)."),
+    matched_traits: z.array(z.string()).describe("Trait dimensions that matched."),
+    reference_examples: z.array(z.object({
+        file: z.string().describe("Example file name (fetch via schema_query search_examples)."),
+        title: z.string(),
+        operation_type: z.string(),
+        verified: z.boolean(),
+    }).strict()).describe("Verified reference examples for this industry (top 3)."),
+}).strict();
 const CreateProjectResultSchema = z
     .object({
     action: z.literal("create_project"),
@@ -494,10 +814,24 @@ const CreateProjectResultSchema = z
         steps_count: z.number().describe("Number of deployment steps in the template."),
         scenarios_count: z.number().describe("Number of scenarios in the template."),
         key_risk: z.string().nullable().optional().describe("Industry-specific key risk note (or null)."),
-    }).strict().optional().describe("Blueprint summary — present when industry template applied successfully. Objects have status='draft' and address='draft:<name>'."),
+        intent_inference: z.object({
+            traits: z.record(z.string(), z.unknown()).describe("10-dimension inferred industry traits (unmatched traits use neutral defaults)."),
+            confidence: z.number().describe("Inference confidence 0-1 (matched trait count / 10)."),
+            matched_keywords: z.array(z.string()).describe("Keywords that triggered trait inference."),
+            top_matches: z.array(z.object({
+                industry: z.string(),
+                similarity: z.number().describe("Trait similarity 0-1."),
+            }).strict()).describe("Top-3 similar industries by trait similarity."),
+        }).strict().optional().describe("Intent inference summary (E.3) — present when industry template applied."),
+        industry_mismatch_hint: z.string().optional().describe("Advisory hint — present when intent inference suggests a different industry fits the description better (non-blocking)."),
+    }).strict().optional().describe("Blueprint summary — present when industry template applied successfully. Objects have status='draft' and address='draft:<name>'. Full steps/scenarios persisted as project document doc_type='blueprint'."),
     blueprint_warning: z.string().optional().describe("Warning message — present when industry template application failed. Project is created without blueprint; use add_object to manually add objects."),
     blueprint_skipped: z.boolean().optional().describe("True when skip_templates=true was passed — no industry blueprint objects were created."),
     hint: z.string().optional().describe("User-facing hint — guides to next action (e.g. add_object, generate_deployment_doc)."),
+    recommended_industries: z.array(RecommendedIndustryItemSchema).optional().describe("Top-3 recommended industry modes inferred from the project description (E.7). " +
+        "Present only when no project_industry was given. Each item includes reference examples " +
+        "('standing on giants' shoulders'). To apply: call update_project is NOT enough — recreate " +
+        "via create_project with project_industry set to get the blueprint."),
 })
     .strict();
 const CreateProjectFromOnchainResultSchema = z
@@ -1095,6 +1429,525 @@ const MigrateToMainnetResultSchema = z
     summary: z.string().describe("Human-readable summary of the migration."),
 })
     .strict();
+const RecommendIndustryResultSchema = z
+    .object({
+    action: z.literal("recommend_industry"),
+    intent: z.string().describe("The intent text used for inference."),
+    inferred_traits: z.record(z.unknown()).describe("10-dim industry traits inferred from intent."),
+    inference_confidence: z.number().describe("Inference confidence 0-1 (matched trait count / 10)."),
+    matched_keywords: z.array(z.string()).describe("Keywords that triggered trait inference."),
+    recommendations: z.array(RecommendedIndustryItemSchema).describe("Top-3 similar industries + reference examples."),
+    hint: z.string().describe("How to apply the recommendation (create_project with project_industry)."),
+})
+    .strict();
+const ModeSummarySchema = z.object({
+    name: z.string(),
+    display_name: z.string(),
+    version: z.string(),
+    derived_from: z.string().nullable().describe("Source builtin mode (derive_user_mode) or null."),
+    owner: z.string().optional().describe("Mode owner (custom modes only)."),
+    key_risk: z.string(),
+    machine_nodes: z.array(z.string()).describe("Machine shape node names."),
+    similar_industries: z.array(z.string()).optional(),
+    evolution_history: z.array(z.object({
+        version: z.string(),
+        changed_at: z.number(),
+        changes: z.array(z.string()),
+    }).strict()).optional(),
+}).strict();
+const ListModesResultSchema = z
+    .object({
+    action: z.literal("list_modes"),
+    builtin_modes: z.array(ModeSummarySchema).describe("Builtin industry modes (use name as project_industry)."),
+    user_modes: z.array(ModeSummarySchema).describe("Caller's custom modes (derive/evolve/register)."),
+    owner: z.string().describe("Owner key for custom modes (local single-user)."),
+    hint: z.string(),
+})
+    .strict();
+const DeriveUserModeResultSchema = z
+    .object({
+    action: z.literal("derive_user_mode"),
+    mode: ModeSummarySchema.describe("The derived (and registered) custom mode."),
+    hint: z.string(),
+})
+    .strict();
+const EvolveUserModeResultSchema = z
+    .object({
+    action: z.literal("evolve_user_mode"),
+    mode: ModeSummarySchema.describe("The evolved custom mode (version bumped)."),
+    hint: z.string(),
+})
+    .strict();
+const RegisterUserModeResultSchema = z
+    .object({
+    action: z.literal("register_user_mode"),
+    mode: ModeSummarySchema.describe("The registered fully-custom mode."),
+    hint: z.string(),
+})
+    .strict();
+const UnregisterUserModeResultSchema = z
+    .object({
+    action: z.literal("unregister_user_mode"),
+    removed: z.literal(true),
+    mode_name: z.string(),
+})
+    .strict();
+const MetricInfoSchema = z.object({
+    metric_id: z.string(),
+    display_name: z.string(),
+    description: z.string(),
+    type: z.enum(["risk", "benefit"]),
+    scale: z.enum(["level", "numeric", "percentage"]),
+    weight: z.number(),
+    scope: z.enum(["builtin", "custom"]),
+    owner: z.string().optional(),
+}).strict();
+const RegisterCustomMetricResultSchema = z
+    .object({
+    action: z.literal("register_custom_metric"),
+    metric: MetricInfoSchema.describe("The registered custom metric (globally effective)."),
+    hint: z.string(),
+})
+    .strict();
+const ConstraintInfoSchema = z.object({
+    constraint_id: z.string(),
+    display_name: z.string(),
+    description: z.string(),
+    rule: z.record(z.unknown()).describe("Constraint rule (4 types — see constraint_rule input)."),
+    severity: z.enum(["hard", "soft"]),
+    on_violation: z.enum(["block", "warn", "log"]),
+    scope: z.enum(["builtin", "custom"]),
+    owner: z.string().optional(),
+}).strict();
+const RegisterCustomConstraintResultSchema = z
+    .object({
+    action: z.literal("register_custom_constraint"),
+    constraint: ConstraintInfoSchema.describe("The registered custom constraint."),
+    hint: z.string(),
+})
+    .strict();
+const ListMetricsConstraintsResultSchema = z
+    .object({
+    action: z.literal("list_metrics_constraints"),
+    metrics: z.array(MetricInfoSchema),
+    constraints: z.array(ConstraintInfoSchema),
+    hint: z.string(),
+})
+    .strict();
+const KeywordMatchSchema = z
+    .object({
+    keyword: z.string(),
+    category: z.string(),
+    matched_objects: z.array(z.string()),
+    required_level: z.enum(["R", "C", "OPTIONAL"]),
+    match_count: z.number(),
+})
+    .strict();
+const AnalyzeIntentResultSchema = z
+    .object({
+    action: z.literal("analyze_intent"),
+    intent_parsed: z
+        .object({
+        primary_object: z.string().describe("Primary object inferred from the intent keywords."),
+        secondary_objects: z.array(z.string()).describe("Supporting objects typically required alongside the primary one."),
+        detected_scenes: z
+            .array(z
+            .object({
+            object: z.string(),
+            scene_id: z.string().describe("Free-form scene id, e.g. 'retail', 'rental_return'."),
+        })
+            .strict())
+            .describe("Scenes detected from the intent (used for template selection)."),
+        industry: z.string().describe("Industry mode resolved from the intent (defaults to 'general')."),
+        keyword_matches: z.array(KeywordMatchSchema).describe("All keyword matches that drove the identification."),
+    })
+        .strict(),
+    puzzles: z
+        .record(z
+        .object({
+        puzzle: z.unknown(),
+        completeness: z.unknown(),
+        missing_dimensions: z.array(z.string()),
+    })
+        .strict())
+        .describe("Per-object puzzle snapshot, keyed by object_type. Pass this UNCHANGED to aggregate_risks."),
+    overall_completeness: z.enum(["complete", "partial", "empty"]),
+    next_step: z.string().describe("Human-readable suggestion for the next puzzle step."),
+    recommended_creation_order: z.array(z.string()).describe("Recommended object creation order (dependency topology)."),
+    warnings: z.array(z.string()),
+})
+    .strict();
+const AggregatedRiskSchema = z
+    .object({
+    risk_rule_id: z.string().describe("Unified risk rule id, e.g. 'R-S-01'."),
+    object_type: z.string(),
+    entry_id: z.string().describe("Object entry_id ('*' when cross-object)."),
+    severity: z.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"]),
+    message: z.string(),
+    fix_suggestion: z.string(),
+    details: z
+        .object({
+        field_path: z.string().optional(),
+        actual_value: z.unknown().optional(),
+        expected_value: z.unknown().optional(),
+        rule_source: z.string().optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const SafetyFindingSchema = z
+    .object({
+    rule_id: z.string().describe("Safety rule id (e.g. 'REUSE-SERVICE-01', 'IMMUT-001')."),
+    severity: z.enum(["info", "warn"]),
+    message: z.string(),
+})
+    .strict();
+const AggregateRisksResultSchema = z
+    .object({
+    action: z.literal("aggregate_risks"),
+    namespace: z
+        .object({
+        prefix: z.string(),
+        version: z.string(),
+        industry: z.string().optional(),
+    })
+        .strict(),
+    findings: z.array(AggregatedRiskSchema).describe("All risks found, sorted (CRITICAL first)."),
+    severity_summary: z.record(z.number()).describe("Counts keyed by severity."),
+    status: z
+        .enum(["RISK_PASSED", "RISK_BLOCKED", "RISK_PENDING_CONFIRM", "RISK_CANCELLED"])
+        .describe("Aggregated status (62-spec §3.2). RISK_BLOCKED = CRITICAL or above-threshold risks present."),
+    pending_confirmations: z
+        .array(z
+        .object({
+        risk_rule_id: z.string(),
+        description: z.string(),
+        fix_suggestion: z.string(),
+        object_type: z.string(),
+        entry_id: z.string(),
+    })
+        .strict())
+        .optional()
+        .describe("HIGH risks awaiting user confirmation (only when status='RISK_PENDING_CONFIRM')."),
+    calibrated_at: z.number().describe("Calibration timestamp (ms)."),
+    fix_suggestions_grouped: z
+        .record(z.array(z
+        .object({
+        risk_rule_id: z.string(),
+        severity: z.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"]),
+        message: z.string(),
+        fix_suggestion: z.string(),
+        entry_id: z.string(),
+    })
+        .strict()))
+        .optional()
+        .describe("Fix suggestions grouped by object_type."),
+    safety_findings: z
+        .array(SafetyFindingSchema)
+        .optional()
+        .describe("OBJECT_REUSE / IMMUTABILITY findings from safety-rules (only when planned_objects / planned_operations were provided)."),
+    intent_echo: z
+        .object({
+        primary_object: z.string(),
+        industry: z.string(),
+        overall_completeness: z.enum(["complete", "partial", "empty"]),
+    })
+        .strict()
+        .optional()
+        .describe("Echo of the auto-run analyze_intent (only when 'puzzles' was omitted and 'intent' was used)."),
+    warnings: z.array(z.string()),
+})
+    .strict();
+const TraceSubstepsResultSchema = z
+    .object({
+    action: z.literal("trace_substeps"),
+    namespace: z.object({ prefix: z.string(), version: z.string() }).strict(),
+    network: z.enum(["testnet", "mainnet"]),
+    coherent: z.boolean().describe("True when no dangling inputs, no cycles, no missing outputs, no cross-step breaks."),
+    dangling_inputs: z
+        .array(z.object({ substep_id: z.string(), missing_ref: z.string(), field_path: z.string() }).strict())
+        .describe("Input refs pointing to non-existent substeps."),
+    circular_refs: z
+        .array(z.object({ cycle: z.array(z.string()) }).strict())
+        .describe("Substep id cycles (when present, topological_order is empty)."),
+    missing_outputs: z
+        .array(z
+        .object({
+        substep_id: z.string(),
+        expected_field: z.string(),
+        dependent_substeps: z.array(z.string()),
+    })
+        .strict())
+        .describe("Substeps that should have produced a field but did not."),
+    cross_step_breaks: z
+        .array(z
+        .object({
+        source_step: z.string(),
+        target_step: z.string(),
+        missing_field: z.string(),
+    })
+        .strict())
+        .describe("Upstream step failed → downstream cannot proceed."),
+    step_details: z
+        .array(z
+        .object({
+        parent_step: z.string(),
+        total_substeps: z.number(),
+        successful: z.number(),
+        failed: z.number(),
+        pending: z.number(),
+        skipped: z.number(),
+        substep_ids: z.array(z.string()),
+    })
+        .strict())
+        .describe("Per-step summary, keyed by parent_step."),
+    topological_order: z.array(z.string()).describe("Topological order of substep ids (empty when a cycle exists)."),
+    d10_check: z
+        .object({
+        check_id: z.literal("D-10"),
+        description: z.string(),
+        status: z.enum(["PASS", "FAIL", "WARN"]),
+        notes: z.array(z.string()),
+    })
+        .strict()
+        .describe("D-10 substep linkage completeness verdict."),
+})
+    .strict();
+const MerchantGuideResultSchema = z
+    .object({
+    action: z.literal("merchant_guide"),
+    current_step: z.number().describe("Furthest wizard step reached (2 = awaiting industry confirmation; 9 = harness issues found; 10 = plan ready)."),
+    step_name: z.string(),
+    guide_state: z
+        .object({
+        intent_text: z.string(),
+        confirmed_industry: z.string().optional(),
+        currency: z.string().optional(),
+        deliverables: z.array(z.unknown()).optional(),
+        payment_override: z.record(z.unknown()).optional(),
+        trust_override: z.record(z.unknown()).optional(),
+        adopted_module_ids: z.array(z.string()).optional(),
+    })
+        .strict()
+        .describe("Wizard state — pass back UNCHANGED on the next merchant_guide call."),
+    intent_draft: z.unknown().optional().describe("Step 1-2 only: BusinessIntent draft inferred from the description."),
+    industry_options: z
+        .object({
+        inferred: z.string(),
+        confidence: z.number(),
+        similar: z.array(z.string()),
+    })
+        .strict()
+        .optional()
+        .describe("Step 2 only: industry candidates awaiting merchant confirmation."),
+    intent: z.unknown().optional().describe("Steps 7-10: final BusinessIntent after merchant overrides."),
+    adopted_modules: z
+        .array(z
+        .object({
+        id: z.string(),
+        name: z.string(),
+        description: z.string(),
+        requires_keeper: z.boolean(),
+        keeper_hint: z.string().optional(),
+        user_protections: z.array(z.string()),
+        merchant_obligations: z.array(z.string()),
+    })
+        .strict())
+        .optional()
+        .describe("Steps 6-10: adopted business modules with protections/obligations."),
+    blueprint: z
+        .object({
+        nodes: z.array(z.object({ id: z.string(), type: z.string(), purpose: z.string() }).strict()),
+        edges: z.array(z.object({ from: z.string(), to: z.string(), relation: z.string(), required: z.boolean() }).strict()),
+    })
+        .strict()
+        .optional()
+        .describe("Step 7: semantic object graph (nodes + edges)."),
+    evaluation_preview: z.unknown().optional().describe("Step 8: estimated risk/trust/completeness scores + key risks + module boosts."),
+    graph_validation: z
+        .object({
+        valid: z.boolean(),
+        hard_violations: z.array(z.object({ id: z.string(), description: z.string(), fix: z.string().optional() }).strict()),
+        soft_notes: z.array(z.object({ id: z.string(), description: z.string() }).strict()),
+    })
+        .strict()
+        .optional()
+        .describe("Step 8: structural validation of the semantic graph."),
+    harness_check: z
+        .object({
+        module_constraints: z.array(z.object({
+            module: z.string(),
+            plan_satisfied: z.boolean(),
+            missing: z.array(z.string()).optional(),
+            reason: z.string().optional(),
+            estimated_score_boost: z.number(),
+        }).strict()),
+        blocking_issues: z.array(z.object({
+            module: z.string(),
+            missing_constraints: z.array(z.string()).optional(),
+            fix: z.string().optional(),
+        }).strict()),
+        deploy_time_checks: z.array(z.string()),
+    })
+        .strict()
+        .optional()
+        .describe("Step 9: module constraint check at blueprint stage + deploy-time checklist."),
+    game_theory: z
+        .object({
+        summary: z.string(),
+        coverage: z.string().describe("Covered/total scenario count, e.g. '4/5'."),
+        exposed_scenarios: z.array(z.string()),
+        wow_alignments: z.array(z.string()).describe("Active WOW mechanisms aligning merchant/user incentives."),
+        scenarios: z.array(z.object({
+            scenario: z.string(),
+            covered: z.boolean(),
+            conflict: z.string(),
+            user_protection: z.string(),
+            evaluation_metric: z.string(),
+            recommendation: z.string().optional(),
+        }).strict()),
+    })
+        .strict()
+        .optional()
+        .describe("Step 9 (GLM6/93 §2.3): merchant-user adversarial scenario coverage. 5 canonical scenarios checked against the blueprint; exposed scenarios include fix recommendations."),
+    creation_plan: z
+        .array(z.object({
+        order: z.number(),
+        node_id: z.string(),
+        object_type: z.string(),
+        suggested_name: z.string(),
+        depends_on: z.array(z.string()),
+        operation_hint: z.string(),
+    }).strict())
+        .optional()
+        .describe("Step 10: topologically ordered creation plan. NOT executed — materialize via create_project + onchain_operations."),
+    warnings: z.array(z.string()),
+    next_action: z.string().describe("Human-readable guidance for the next call."),
+})
+    .strict();
+const RadarMonitorAlertSchema = z
+    .object({
+    id: z.string(),
+    category: z.enum([
+        "progress_stall", "compensation_drop", "compensation_insufficient",
+        "messenger_timeout", "user_action_required", "review_window",
+        "arb_window", "refund_received", "anomaly",
+    ]),
+    severity: z.enum(["info", "warning", "critical"]),
+    title: z.string(),
+    message: z.string(),
+    action: z.string().optional().describe("Suggested next step."),
+    timestamp: z.number(),
+    order_id: z.string().optional(),
+    service_id: z.string().optional(),
+    node: z.string().optional(),
+    metric: z
+        .object({
+        label: z.string(),
+        value: z.number(),
+        threshold: z.number().optional(),
+        unit: z.string().optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const RadarForwardSchema = z
+    .object({
+    name: z.string().describe("Forward (operation) name."),
+    to_node: z.string().describe("Target node after execution."),
+    execution_path: z
+        .enum(["order_holder", "permission", "named_operator", "not_available"])
+        .describe("How this account may execute it (not_available if it can't)."),
+    permission_index: z.number().optional().describe("Permission index required (if permission-gated)."),
+    named_operator: z.string().optional().describe("Named operator (LocalMark name) required (if named-gated)."),
+    guard: z.string().optional().describe("Guard address gating this forward."),
+    semantics: z.string().describe("Human explanation of what executing this forward means."),
+    consequence: z.string().optional().describe("Consequence hint (completion fund-release / refund path)."),
+})
+    .strict();
+const RadarPendingClaimSchema = z
+    .object({
+    kind: z.enum(["reward", "discount", "compensation", "rating"]),
+    label: z.string(),
+    how: z.string().describe("How to claim (tool + operation hint)."),
+})
+    .strict();
+const MerchantInterestAnalysisSchema = z
+    .object({
+    fund_flow: z
+        .array(z.string())
+        .describe("Where money sits and what releases it (escrow, Allocation waterfall, compensation_fund)."),
+    responsibility: z
+        .array(z.string())
+        .describe("What this account is semantically liable for right now (permission-gated forwards, guard obligations)."),
+    leverage: z
+        .array(z.string())
+        .describe("Actions serving the merchant's own interest (settlement speed, evidence pre-upload, Messenger nudge). Informational only."),
+    stakes: z
+        .array(z.string())
+        .describe("Downside exposure (arbitration indemnity, arb-loss record, stall statistics, refund aftermath)."),
+    summary: z.string().describe("One-paragraph merchant-interest summary."),
+})
+    .strict();
+const OrderRadarResultSchema = z
+    .object({
+    account: z.string(),
+    progress: z.string(),
+    order: z.string().optional(),
+    current_node: z.string().describe("Current node name ('' = entry, not yet started)."),
+    perspective: z
+        .enum(["customer", "operator", "observer"])
+        .describe("Derived from on-chain data (Order.builder + PermissionPerm grants), never caller-asserted."),
+    roles: z
+        .array(z.object({ label: z.string(), can_act_now: z.boolean() }).strict())
+        .describe("All roles this account holds on this order's workflow."),
+    operable: z.array(RadarForwardSchema).describe("Forwards THIS account can execute NOW (branch options if >1)."),
+    branch_choice: z
+        .object({
+        message: z.string(),
+        options: z.array(z.object({ forward: z.string(), to_node: z.string(), consequence: z.string().optional() }).strict()),
+    })
+        .strict()
+        .optional()
+        .describe("Present when >1 operable forward. AI MUST present options neutrally; the role decides."),
+    waiting_on: z
+        .array(z.object({ role: z.string(), forwards: z.array(z.string()) }).strict())
+        .describe("What the workflow is waiting on from OTHER roles."),
+    pending_claims: z.array(RadarPendingClaimSchema).describe("Unclaimed benefits / post-purchase actions."),
+    interest_hints: z
+        .array(z.string())
+        .describe("Perspective-specific own-interest hints (fund-release trigger, settlement cycle, reputation)."),
+    workflow_unknown: z.boolean().describe("True when Machine data was unavailable — operable/waiting_on unknown."),
+    interest_analysis: MerchantInterestAnalysisSchema.optional().describe("Merchant-side interest analysis (fund_flow/responsibility/leverage/stakes) — present ONLY when perspective='operator' " +
+        "and order data is available. AI MUST surface it as neutral information; the merchant decides."),
+    summary: z.string().describe("One-paragraph AI-ready summary."),
+    attached_alerts: z
+        .array(RadarMonitorAlertSchema)
+        .optional()
+        .describe("Order-monitor alerts (stall/compensation/review-window) when radar_include_alerts=true."),
+})
+    .strict();
+const ParticipationRadarResultSchema = z
+    .object({
+    action: z.literal("participation_radar"),
+    account: z.string().describe("Resolved account address."),
+    orders_analyzed: z.number(),
+    actionable: z
+        .array(OrderRadarResultSchema)
+        .describe("Orders where the account can act NOW or has pending claims (customer perspective first)."),
+    waiting: z.array(OrderRadarResultSchema).describe("Orders where the account is only waiting on other roles."),
+    all_pending_claims: z
+        .array(RadarPendingClaimSchema.extend({ progress: z.string() }))
+        .describe("All pending claims across orders, tagged with their Progress address."),
+    unread_messages_total: z.number().describe("Unread Messenger messages total across all conversations of the radar account (local encrypted storage, read-only — never marks messages viewed; 0 with a data_gaps note when the account is not a local messenger account)."),
+    data_gaps: z
+        .array(z.string())
+        .describe("Graceful degradation notes (e.g. 'Order 0x… not found', 'Machine nodes unavailable')."),
+    summary: z.string().describe("Account-level dashboard summary."),
+})
+    .strict();
 export const ProjectOperationOutputSchema = z
     .object({
     result: z.discriminatedUnion("action", [
@@ -1128,6 +1981,20 @@ export const ProjectOperationOutputSchema = z
         CloneProjectToNetworkResultSchema,
         MigrateNetworkResultSchema,
         MigrateToMainnetResultSchema,
+        RecommendIndustryResultSchema,
+        ListModesResultSchema,
+        DeriveUserModeResultSchema,
+        EvolveUserModeResultSchema,
+        RegisterUserModeResultSchema,
+        UnregisterUserModeResultSchema,
+        RegisterCustomMetricResultSchema,
+        RegisterCustomConstraintResultSchema,
+        ListMetricsConstraintsResultSchema,
+        AnalyzeIntentResultSchema,
+        AggregateRisksResultSchema,
+        TraceSubstepsResultSchema,
+        MerchantGuideResultSchema,
+        ParticipationRadarResultSchema,
     ]).describe("Query result — shape depends on action"),
     skills_recommended: z.string().optional().describe("Skills recommendation hint (F-10). Informational only — MCP executes " +
         "independently of skills. Present when the action benefits from skills' " +