@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/schema/project/index.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 const IndustryEnum = z.enum([
     "general",
     "retail",
+    "retail_d2c",
     "service",
     "rental",
     "freelance",
@@ -70,11 +71,31 @@ export const ProjectOperationInputSchema = z
         "delete_project",
         "assemble_context",
         "get_machine_graph",
+        "get_guard_graph",
         "generate_deployment_doc",
         "pre_evaluate_check",
         "verify_deployment",
         "clone_project_to_network",
         "migrate_network",
+        "migrate_to_mainnet",
+        "plan_object_edit",
+        "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" +
@@ -83,7 +104,10 @@ export const ProjectOperationInputSchema = z
     project: z
         .string()
         .optional()
-        .describe("Project prefix (human-readable unique identifier). Used by create_version, build_graph, evaluate_project, etc. Takes precedence resolution: project_id > project (prefix)."),
+        .describe("Project prefix (human-readable unique identifier). " +
+        "For create_project: OPTIONAL — if omitted, auto-derived from project_name (e.g. 'Twitch Service' → 'twitch_service'). " +
+        "For other actions (build_graph, evaluate_project, etc.): used to identify the project. " +
+        "Takes precedence resolution: project_id > project (prefix)."),
     version: z
         .string()
         .regex(/^v\d+$/)
@@ -128,7 +152,8 @@ export const ProjectOperationInputSchema = z
         "(and not 'general'), the system auto-applies an industry blueprint " +
         "with ~10 draft objects (Permission, Service, Machine, Guard, Treasury, " +
         "Allocation, etc.) + graph edges, ready for deployment. " +
-        "Supported industries: 'general' (no template), 'retail', 'service', " +
+        "Supported industries: 'general' (no template), 'retail', 'retail_d2c' " +
+        "(Direct-to-Consumer, e.g., Shopify — Allocation escrow + 2 Guards), 'service', " +
         "'rental', 'freelance', 'education', 'travel', 'subscription', 'custom'. " +
         "Each industry preset embeds risk constraints (e.g., 'freelance' does " +
         "NOT require compensation_fund, while 'rental'/'travel' do). " +
@@ -269,7 +294,11 @@ export const ProjectOperationInputSchema = z
     refresh_before_eval: z
         .boolean()
         .optional()
-        .describe("When true, evaluate_project refreshes object cache from chain before evaluating. Default false."),
+        .describe("When true (DEFAULT), evaluate_project refreshes object cache from chain before evaluating. " +
+        "Set to false ONLY for read-only checks where staleness is acceptable (e.g., quick comparisons). " +
+        "BUG-P0-2 fix: previously defaulted to false, causing stale Machine node_count and other " +
+        "dynamic-field-derived fields to produce false findings (e.g., 'Machine has no nodes'). " +
+        "Now defaults to true — set refresh_before_eval=false explicitly to skip refresh."),
     eval_score: z
         .number()
         .min(0)
@@ -320,6 +349,351 @@ export const ProjectOperationInputSchema = z
         "'detailed': adds sale list, arbitration list, reward list. " +
         "'full': complete fields including stock, price, wip_hash, all config. " +
         "Use 'summary' for quick review; request 'detailed' or 'full' only when deeper inspection is needed."),
+    object_kind: z
+        .enum(["machine", "guard"])
+        .optional()
+        .describe("Object kind for plan_object_edit. 'machine' = Machine workflow directed graph (cycles allowed), 'guard' = Guard computation tree. " +
+        "Required when action='plan_object_edit'. Inferred from action for patch_machine_nodes (always 'machine') " +
+        "and patch_guard_tree (always 'guard')."),
+    edit_format: z
+        .enum(["tree_outline", "json"])
+        .optional()
+        .describe("Format of the edited content for plan_object_edit. " +
+        "'tree_outline' (default): the indented Markdown outline produced by get_machine_graph / get_guard_graph (human-editable). " +
+        "'json': raw JSON (machine-readable, for programmatic edits). " +
+        "Both formats are bidirectional with the parse functions in knowledge/machine-render.ts / guard-render.ts."),
+    edited_content: z
+        .string()
+        .optional()
+        .describe("Edited content for plan_object_edit. Must be in the format specified by edit_format. " +
+        "For 'tree_outline': the full tree_outline string from get_machine_graph/get_guard_graph with user edits. " +
+        "For 'json': a JSON string matching the Machine/Guard schema. " +
+        "The content is parsed + validated + diffed against the current on-chain state."),
+    plan_id: z
+        .string()
+        .optional()
+        .describe("Plan ID returned by plan_object_edit. Required for apply_object_edit. " +
+        "The plan is short-lived (10-minute TTL) and stored in-memory."),
+    expected_hash: z
+        .string()
+        .optional()
+        .describe("Expected hash returned by plan_object_edit. Required for apply_object_edit. " +
+        "Used for optimistic concurrency control: if the on-chain state changed between plan and apply, " +
+        "the hash will mismatch and apply will refuse to proceed (stale edit protection)."),
+    patch_operations: z
+        .array(z.string())
+        .optional()
+        .describe("Patch operations for patch_machine_nodes / patch_guard_tree. Each string is a single patch operation.\n" +
+        "Machine operations (13 total):\n" +
+        "  'add node <name>' | 'remove node <name>' | 'set description <node_name> <text...>'\n" +
+        "  'add edge <from> <to>' | 'remove edge <from> <to>' | 'set threshold <edge_from> <edge_to> <value>'\n" +
+        "  'add forward <edge_from> <edge_to> <forward_name>' | 'remove forward <edge_from> <edge_to> <forward_name>'\n" +
+        "  'set guard <edge_from> <edge_to> <forward_name> <guard_addr_or_name|none>'\n" +
+        "  'set permission <edge_from> <edge_to> <forward_name> <perm_index>'\n" +
+        "  'set operator <edge_from> <edge_to> <forward_name> <named_operator|none>'\n" +
+        "  'set weight <edge_from> <edge_to> <forward_name> <weight>'\n" +
+        "  'set retained_submission <edge_from> <edge_to> <forward_name> <comma_separated_indices|none>'\n" +
+        "Guard operations (8 total — see patch_guard_tree):\n" +
+        "  'add table <identifier> <name|none> <value_type> <b_submission> [json_value]'\n" +
+        "  'remove table <identifier>' | 'set table_value <identifier> [json_value|none]'\n" +
+        "  '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
@@ -415,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"),
@@ -429,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
@@ -695,7 +1094,7 @@ const GenerateDeploymentDocResultSchema = z
             status: z.enum(["PASS", "WARN", "FAIL"]).describe("Check result status."),
             message: z.string().describe("Human-readable check result message."),
         }).strict()).describe("Per-dimension check results."),
-    }).strict().describe("Stage gate validation (GLM6 5-stage lifecycle 衔接). Validates Stage 3 risk score threshold (>=80 PASS, >=50 WARN, <50 FAIL) and Stage 4 deployment doc generation prerequisite."),
+    }).strict().describe("Stage gate validation (GLM6 5-stage lifecycle handoff). Validates Stage 3 risk score threshold (>=80 PASS, >=50 WARN, <50 FAIL) and Stage 4 deployment doc generation prerequisite."),
     deployment_scan: z.object({
         overall_readiness: z.enum(["ready", "blocked", "warnings"]).describe("'ready' = all 20 checks pass; 'blocked' = any critical fail; 'warnings' = only warning fails."),
         critical_count: z.number().describe("Number of critical findings (blocks deployment)."),
@@ -817,6 +1216,158 @@ const GetMachineGraphResultSchema = z
     edges: z.array(MachineGraphEdgeSchema).describe("Directed edges (pairs) connecting nodes. Each edge has a threshold and forwards."),
     published: z.boolean().nullable().describe("Whether the Machine is published (locked for production). null = unknown."),
     paused: z.boolean().nullable().describe("Whether the Machine is paused (not generating new Progress). null = unknown."),
+    mermaid: z.string().describe("Mermaid stateDiagram-v2 string visualizing the directed graph. Entry nodes start from [*]. Edge labels include forward name + threshold + guard info. Cycles (revision loops) are rendered as normal edges. Includes a color legend comment block + BehaviorTree.CPP-style color annotations (entry=green, terminal=red, revision=amber, normal=blue). Renderable in markdown viewers."),
+    tree_outline: z.string().describe("Indented Markdown outline of the directed graph (human-editable format). Lists edges as outline entries with forwards nested under each edge. Includes a Backrefs section consolidating incoming edges per node (editing aid — answers 'who transitions INTO node X?'). Bidirectional with parseMachineTreeIndented(). Includes JSON code block for round-trip safety. Use this for the download -> edit -> republish workflow."),
+    ascii_art: z.string().describe("ASCII art directed graph visualization using arrow notation (A -forward-> B). Cycle (revision loop) and terminal annotations included. Terminal-friendly, avoids JSON escaping issues that affect multi-line Mermaid strings. Use when rendering in plain-text contexts."),
+    markmap: z.string().describe("Markmap-compatible Markdown string (heading levels represent hierarchy). Edge-centric layout with forwards nested under edges. Renderable by VS Code Markmap extension or markmap.js. Provides an interactive mind-map view of the workflow."),
+})
+    .strict();
+const GuardGraphNodeSchema = z.lazy(() => z.object({
+    type: z.string().describe("Guard node type (logic_and, query, identifier, context, calc_*, convert_*, vec_*, etc.)."),
+    nodes: z.array(GuardGraphNodeSchema).optional().describe("Child nodes (for logic_and/or, calc_*, vec_contains_*, etc.)."),
+    node: GuardGraphNodeSchema.optional().describe("Single child (for logic_not, convert_*, value_type)."),
+    nodeLeft: GuardGraphNodeSchema.optional().describe("Left child (for vec_indexof_*)."),
+    nodeRight: GuardGraphNodeSchema.optional().describe("Right child (for vec_indexof_*)."),
+    query: z.union([z.number(), z.string()]).optional().describe("Query instruction ID or name (for query nodes)."),
+    object: z.object({
+        identifier: z.number().optional(),
+        convert_witness: z.number().optional(),
+    }).optional().describe("Query target object reference."),
+    parameters: z.array(GuardGraphNodeSchema).optional().describe("Query parameters."),
+    identifier: z.number().optional().describe("Table entry index (for identifier nodes)."),
+    context: z.string().optional().describe("Context type: Signer, Clock, or Guard."),
+}).strict());
+const GuardTableEntrySchema = z.object({
+    identifier: z.number().describe("Table entry index (0-255)."),
+    b_submission: z.boolean().describe("Whether this entry is submitted at runtime."),
+    value_type: z.union([z.number(), z.string()]).describe("Value type (numeric code or name)."),
+    value: z.unknown().optional().describe("Constant value (if b_submission=false)."),
+    name: z.string().optional().describe("Human-readable name/description."),
+}).strict();
+const GetGuardGraphResultSchema = z
+    .object({
+    action: z.literal("get_guard_graph"),
+    guardAddress: z.string().describe("The Guard object address."),
+    guardName: z.string().nullable().describe("The Guard's local name (from LocalMark) if available."),
+    root: GuardGraphNodeSchema.describe("Root computation node (returns Bool). The tree is recursive — each node may have children."),
+    table: z.array(GuardTableEntrySchema).describe("Guard data table entries (constants + submission slots)."),
+    rely: z.object({
+        guards: z.array(z.string()),
+        logic_or: z.boolean().optional(),
+    }).nullable().describe("Rely dependencies (other Guards this Guard depends on). null = no rely."),
+    immutable: z.boolean().nullable().describe("Whether the Guard is immutable (frozen for verification). null = unknown."),
+    mermaid: z.string().describe("Mermaid flowchart TD string visualizing the tree. Node shapes: {}=decision (logic_*), []=computation/query, ([])=leaf (identifier), {{}}=context. Includes a color legend comment block + BehaviorTree.CPP-style color annotations (control=blue, decision=amber, computation=purple, query=cyan, leaf=gray, context=green)."),
+    tree_outline: z.string().describe("Indented Markdown outline of the tree (human-editable format). Bidirectional with parseGuardTreeIndented(). Includes JSON code block for round-trip safety."),
+    ascii_art: z.string().describe("ASCII art tree visualization using box-drawing characters (+-- --, |). Table summary appended. Terminal-friendly, avoids JSON escaping issues that affect multi-line Mermaid strings."),
+    markmap: z.string().describe("Markmap-compatible Markdown string (heading levels represent tree depth). Root -> branches -> leaves hierarchy. Renderable by VS Code Markmap extension or markmap.js. Provides an interactive mind-map view of the Guard tree."),
+})
+    .strict();
+const PlanObjectEditResultSchema = z
+    .object({
+    action: z.literal("plan_object_edit"),
+    plan_id: z.string().describe("Unique plan ID (UUID). Pass to apply_object_edit within 10 minutes to execute."),
+    object_kind: z.enum(["machine", "guard"]).describe("The object kind that was edited."),
+    object_address: z.string().describe("The on-chain object address being edited."),
+    object_name: z.string().nullable().describe("The object's local name (from LocalMark) if available."),
+    expected_hash: z.string().describe("SHA-256 hash of (current_onchain_state + edited_content). Pass to apply_object_edit as expected_hash for stale-edit detection."),
+    diff: z.object({
+        added: z.array(z.string()).describe("List of added items (node names, edge 'from->to', table identifiers, etc.)."),
+        removed: z.array(z.string()).describe("List of removed items."),
+        modified: z.array(z.string()).describe("List of modified items with a brief description of the change."),
+        summary: z.string().describe("Human-readable one-line diff summary (e.g. '2 nodes added, 1 edge removed, 3 forwards modified')."),
+    }).describe("Structured diff between current on-chain state and edited content."),
+    warnings: z.array(z.object({
+        id: z.string().describe("Warning identifier (e.g. 'W-01')."),
+        description: z.string().describe("What the warning is about."),
+        impact: z.string().describe("Potential impact if ignored."),
+    })).describe("Non-blocking warnings (the edit can still proceed, but review is recommended)."),
+    blocking_errors: z.array(z.object({
+        id: z.string().describe("Error identifier (e.g. 'E-01')."),
+        description: z.string().describe("What the error is."),
+        impact: z.string().describe("Why this blocks execution."),
+    })).describe("Blocking errors (the edit CANNOT proceed until these are fixed)."),
+    can_apply: z.boolean().describe("Whether apply_object_edit can proceed. false if blocking_errors is non-empty."),
+    prepared_call: z.unknown().nullable().describe("The prepared onchain_operations call data (operation_type + data). null if can_apply=false. Pass this to onchain_operations to execute the edit."),
+    expires_at: z.string().describe("ISO timestamp when the plan expires (10 minutes from creation). After expiry, apply_object_edit will refuse to proceed."),
+    summary: z.string().describe("Human-readable one-line plan summary."),
+})
+    .strict();
+const ApplyObjectEditResultSchema = z
+    .object({
+    action: z.literal("apply_object_edit"),
+    plan_id: z.string().describe("The plan ID that was applied."),
+    applied: z.boolean().describe("Whether the plan was successfully applied (hash matched and plan was fresh)."),
+    hash_match: z.boolean().describe("Whether the expected_hash matched the stored plan hash. false = stale edit detected."),
+    prepared_call: z.unknown().nullable().describe("The prepared onchain_operations call data. Pass this to onchain_operations to execute the edit on-chain. null if applied=false."),
+    error: z.string().nullable().describe("Error message if applied=false (e.g. 'Plan not found', 'Hash mismatch — on-chain state changed', 'Plan expired'). null on success."),
+    next_step: z.string().describe("Instructions for the next step (typically 'Pass prepared_call to onchain_operations to execute the edit on-chain')."),
+})
+    .strict();
+const PatchMachineNodesResultSchema = z
+    .object({
+    action: z.literal("patch_machine_nodes"),
+    machine_address: z.string().describe("The Machine object address being patched."),
+    machine_name: z.string().nullable().describe("The Machine's local name (from LocalMark) if available."),
+    operations_applied: z.number().describe("Number of patch operations successfully applied."),
+    operations_failed: z.array(z.object({
+        operation: z.string().describe("The original operation string."),
+        error: z.string().describe("Why the operation failed."),
+    })).describe("Operations that failed parse/apply (not applied). Also surfaced as E-OP entries in blocking_errors for schema symmetry with plan_object_edit."),
+    patched_nodes: z.array(z.unknown()).describe("The patched Machine nodes (after applying all successful operations)."),
+    patched_edges: z.array(z.unknown()).describe("The patched Machine edges (after applying all successful operations)."),
+    diff: z.object({
+        added: z.array(z.string()).describe("List of added items."),
+        removed: z.array(z.string()).describe("List of removed items."),
+        modified: z.array(z.string()).describe("List of modified items."),
+        summary: z.string().describe("Human-readable one-line diff summary."),
+    }).describe("Diff between original and patched Machine."),
+    warnings: z.array(z.object({
+        id: z.string().describe("Warning identifier (e.g. 'W-01' unreachable node, 'W-02' self-loop)."),
+        description: z.string().describe("What the warning is about."),
+        impact: z.string().describe("Potential impact if ignored."),
+    })).describe("Non-blocking warnings from validateMachine (W-01 unreachable, W-02 self-loop)."),
+    blocking_errors: z.array(z.object({
+        id: z.string().describe("Error identifier (e.g. 'E-01' no entry forward, 'E-02' orphan endpoint, 'E-03' too many nodes, 'E-OP' operation failed)."),
+        description: z.string().describe("What the error is."),
+        impact: z.string().describe("Why this blocks execution."),
+    })).describe("Blocking errors (operation failures + structural validation). The patch CANNOT proceed until these are fixed. Empty array when can_apply=true."),
+    can_apply: z.boolean().describe("Whether the patch can be applied on-chain. false if any blocking_errors exist (operation failures or validateMachine blocking errors)."),
+    prepared_call: z.unknown().nullable().describe("The prepared onchain_operations call data. null if can_apply=false."),
+    summary: z.string().describe("Human-readable one-line patch summary."),
+})
+    .strict();
+const PatchGuardTreeResultSchema = z
+    .object({
+    action: z.literal("patch_guard_tree"),
+    guard_address: z.string().describe("The Guard object address being patched."),
+    guard_name: z.string().nullable().describe("The Guard's local name (from LocalMark) if available."),
+    operations_applied: z.number().describe("Number of Guard patch operations successfully applied."),
+    operations_failed: z.array(z.object({
+        operation: z.string().describe("The original operation string."),
+        error: z.string().describe("Why the operation failed."),
+    })).describe("Operations that failed parse/apply (not applied). Also surfaced as E-OP entries in blocking_errors."),
+    patched_root: z.unknown().describe("The patched Guard root node (after applying all successful operations). For set_root, this is the new root; otherwise the original root unchanged."),
+    patched_table: z.array(z.unknown()).describe("The patched Guard table entries (after applying all successful table operations)."),
+    patched_rely: z.unknown().nullable().describe("The patched rely field (cross-guard composition). null if rely was cleared or never set. Shape: { guards: string[], logic_or?: boolean }."),
+    diff: z.object({
+        added: z.array(z.string()).describe("List of added items (table entries, tree nodes)."),
+        removed: z.array(z.string()).describe("List of removed items."),
+        modified: z.array(z.string()).describe("List of modified items with a brief description of the change."),
+        summary: z.string().describe("Human-readable one-line diff summary."),
+    }).describe("Diff between original and patched Guard (root tree + table)."),
+    warnings: z.array(z.object({
+        id: z.string().describe("Warning identifier (e.g. 'W-01' dead submission slot, 'W-02' orphan table entry, 'W-03' deep nesting)."),
+        description: z.string().describe("What the warning is about."),
+        impact: z.string().describe("Potential impact if ignored."),
+    })).describe("Non-blocking warnings from validateGuard (W-01 dead submission slot, W-02 orphan table entry, W-03 deep nesting > 16)."),
+    blocking_errors: z.array(z.object({
+        id: z.string().describe("Error identifier (e.g. 'E-01' no root, 'E-02' identifier not in table, 'E-03' table too large, 'E-OP' operation failed)."),
+        description: z.string().describe("What the error is."),
+        impact: z.string().describe("Why this blocks execution."),
+    })).describe("Blocking errors (operation failures + structural validation). The patch CANNOT proceed until these are fixed. Empty array when can_apply=true."),
+    can_apply: z.boolean().describe("Whether the patch can be applied on-chain. false if any blocking_errors exist."),
+    prepared_call: z.unknown().nullable().describe("The prepared onchain_operations call data (operation_type='guard'). null if can_apply=false."),
+    summary: z.string().describe("Human-readable one-line patch summary."),
 })
     .strict();
 const CloneProjectToNetworkResultSchema = z
@@ -841,6 +1392,562 @@ const MigrateNetworkResultSchema = z
     next_steps: z.string().describe("Instructions for deploying the migrated objects on the target network."),
 })
     .strict();
+const MigrationPlanStepSchema = z.object({
+    step: z.number().describe("Step number (1-5)."),
+    status: z.enum(["completed", "pending_user_action"]).describe("Whether this step is done or awaits user action."),
+    action: z.string().describe("The action to perform (e.g. 'clone_project_to_network', 'onchain_operations', 'local_mark_operation', 'update_project', 'build_graph')."),
+    description: z.string().describe("Human-readable description of what this step does."),
+    result: z.string().optional().describe("Result of this step (only present when status='completed')."),
+    deployment_plan: z.array(z.object({
+        order: z.number(),
+        object_type: z.string(),
+        object_name: z.string(),
+        operation_type: z.string(),
+        localmark_name: z.string(),
+        note: z.string(),
+    })).optional().describe("Deployment plan for step 2 (on-chain deployment). Only present for step 2."),
+    names_to_register: z.array(z.string()).optional().describe("LocalMark names to re-register on mainnet. Only present for step 3."),
+    critical_note: z.string().optional().describe("Critical note for this step."),
+}).strict();
+const MigrateToMainnetResultSchema = z
+    .object({
+    action: z.literal("migrate_to_mainnet"),
+    migration_status: z.string().describe("Overall migration status (e.g. 'step_1_complete_steps_2_5_pending_user_action')."),
+    source_project: z.object({
+        prefix: z.string(),
+        network: z.string(),
+        preserved: z.boolean().describe("Whether the source project is preserved unchanged (always true)."),
+    }).strict(),
+    target_project: z.object({
+        prefix: z.string(),
+        project_id: z.string(),
+        network: z.string(),
+        cloned_objects_count: z.number(),
+    }).strict(),
+    key_principle: z.string().describe("Explains that testnet/mainnet are different projects with different addresses for same names."),
+    migration_plan: z.array(MigrationPlanStepSchema).describe("5-step migration plan. Step 1 is completed; steps 2-5 require user action."),
+    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", [
@@ -866,8 +1973,32 @@ export const ProjectOperationOutputSchema = z
         PreEvaluateCheckResultSchema,
         VerifyDeploymentResultSchema,
         GetMachineGraphResultSchema,
+        GetGuardGraphResultSchema,
+        PlanObjectEditResultSchema,
+        ApplyObjectEditResultSchema,
+        PatchMachineNodesResultSchema,
+        PatchGuardTreeResultSchema,
         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' " +
+        "business-semantic guidance (e.g. service/machine/guard/evaluation). " +
+        "Users without skills installed can ignore this field."),
 })
     .strict();