@wowok/agent-mcp 2.6.0 → 2.6.3

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",
@@ -69,15 +70,30 @@ export const ProjectOperationInputSchema = z
         "get_object_diff",
         "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",
     ])
         .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" +
-        "2. Context Assembly (1): assemble_context (query on-chain object states + extract embedded history + optional events, and assemble a structured semantic context for LLM consumption). Required input: context_objects (array of object IDs/names). Optional: include_events (query recent state-transition events)."),
+        "2. Context Assembly (1): assemble_context (query on-chain object states + extract embedded history + optional events, and assemble a structured semantic context for LLM consumption). Required input: context_objects (array of object IDs/names). Optional: include_events (query recent state-transition events).\n" +
+        "3. Cross-Network Migration (FIX-012): clone_project_to_network (or its alias migrate_network) copies a source project's object metadata to a new project bound to target_network. The 5-step migration workflow: 1) call clone_project_to_network (or migrate_network) with target_network to copy metadata, 2) re-run onchain_operations with env.network=target_network to deploy objects on-chain, 3) re-register LocalMark names with the SAME names on the target network (FIX-011 cross-network consistency), 4) update_project to set service_address on the new project, 5) build_graph to construct the new project's relationship graph."),
     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+$/)
@@ -118,7 +134,18 @@ export const ProjectOperationInputSchema = z
         .max(2000)
         .optional()
         .describe("Project description for create_project / update_project."),
-    project_industry: IndustryEnum.optional().describe("Industry tag for create_project. Drives template defaults."),
+    project_industry: IndustryEnum.optional().describe("Industry tag for create_project. Drives template defaults — when set " +
+        "(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', '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). " +
+        "Example: project_industry='freelance' creates a freelance-style " +
+        "blueprint with setting_locked_time ≥ 7d. " +
+        "Set skip_templates=true to bypass template application."),
     project_perspective: z
         .enum(["producer", "consumer", "both"])
         .optional()
@@ -135,6 +162,13 @@ export const ProjectOperationInputSchema = z
         .enum(["testnet", "mainnet"])
         .optional()
         .describe("Network the project is bound to. A Service deployed to different networks are different projects. Defaults to 'testnet'."),
+    skip_templates: z
+        .boolean()
+        .optional()
+        .describe("When true, create_project skips applying the industry template (no draft:* blueprint objects). " +
+        "Use this when you want a clean project with no pre-filled blueprint objects — useful for " +
+        "custom architectures that do not match any industry mode, or to avoid draft objects " +
+        "appearing in build_graph / evaluate_project before deployment. Defaults to false (templates applied)."),
     project_id: z
         .string()
         .optional()
@@ -143,10 +177,20 @@ export const ProjectOperationInputSchema = z
         .enum(["draft", "active", "inactive", "archived"])
         .optional()
         .describe("New status for update_project. 'active' projects are live, 'archived' are read-only."),
+    target_network: z
+        .enum(["testnet", "mainnet"])
+        .optional()
+        .describe("Target network for clone_project_to_network (or its alias migrate_network). " +
+        "The source project's objects are copied to a new project bound to this network. " +
+        "The new project's prefix is '<source_prefix>_<target_network>' to avoid collision. " +
+        "See the action description for the full 5-step migration workflow (FIX-012)."),
     object_address: z
         .string()
         .optional()
-        .describe("On-chain object address (0x...) for add_object / remove_object. For add_object, alternatively use object_name to resolve via LocalMark."),
+        .describe("On-chain object address (0x followed by 32-64 hex chars) for add_object / remove_object. " +
+        "Also accepts the internal 'draft:<name>' sentinel used by create_project for blueprint objects not yet on-chain. " +
+        "For add_object, alternatively use object_name_add to resolve via LocalMark. " +
+        "H-06 fix: invalid formats are rejected at the handler level with a descriptive error."),
     object_name_add: z
         .string()
         .optional()
@@ -207,6 +251,13 @@ export const ProjectOperationInputSchema = z
         .max(5)
         .optional()
         .describe("Max recursion depth for Pathway 1 (internal reference derivation) in build_graph. Default 3."),
+    depth: z
+        .number()
+        .int()
+        .min(1)
+        .max(5)
+        .optional()
+        .describe("Alias for max_depth (build_graph). When both are set, max_depth takes precedence. Default 3."),
     enable_registrar: z
         .boolean()
         .optional()
@@ -215,6 +266,13 @@ export const ProjectOperationInputSchema = z
         .boolean()
         .optional()
         .describe("Enable Pathway 3 (potential relationship detection) in build_graph. Default false."),
+    async_mode: z
+        .boolean()
+        .optional()
+        .describe("When true, build_graph / evaluate_project runs in the background and returns { task_id } immediately. " +
+        "Poll query_task_status(task_id) to check progress and retrieve the result. " +
+        "Default false (synchronous). Use async_mode=true for large projects with enable_potential=true " +
+        "where build may take >10s."),
     evaluation_type: z
         .enum(["risk", "trust", "completeness", "value", "worth_buying"])
         .optional()
@@ -222,7 +280,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)
@@ -265,6 +327,64 @@ export const ProjectOperationInputSchema = z
         .boolean()
         .optional()
         .describe("When true (default), persist the generated MD to SQLite project_documents table for generate_deployment_doc."),
+    detail_level: z
+        .enum(["summary", "detailed", "full"])
+        .optional()
+        .describe("P2-03: Deployment document detail level (only for generate_deployment_doc). " +
+        "'summary' (default): object name + type + key bindings (machine, permission, buy_guard, order_allocators). " +
+        "'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."),
 })
     .strict();
 const AssembleContextResultSchema = z
@@ -314,10 +434,10 @@ const ProjectObjectSchema = z
     .object({
     id: z.string().describe("ProjectObject UUID (project_objects.id)."),
     projectId: z.string().describe("Owning project UUID."),
-    objectAddress: z.string().describe("On-chain object address (0x...)."),
+    objectAddress: z.string().describe("On-chain object address (0x...) or 'draft:<name>' sentinel for blueprint objects."),
     objectType: z.string().nullable().describe("Object type (Service, Machine, etc.) or null if unknown."),
     objectName: z.string().nullable().describe("LocalMark name or null."),
-    role: z.enum(["core", "dependency", "reference"]).describe("Object role in project."),
+    role: z.string().describe("Object role in project. Valid values: 'core' (the Service), 'dependency' (required binding), 'reference' (optional/auxiliary). Other values indicate data corruption — see objectGroups.other bucket."),
     tags: z.array(z.string()).nullable().describe("Tags array or null."),
     addedAt: z.number().describe("Timestamp (ms) when added to project."),
     metadata: z.record(z.unknown()).nullable().describe("Arbitrary metadata key-value pairs or null."),
@@ -354,8 +474,31 @@ const ListProjectsResultSchema = z
     total: z.number().describe("Total number of projects returned."),
 })
     .strict();
+const RecommendedCreationOrderItemSchema = z.object({
+    step: z.number().describe("Step number (1-based)."),
+    object: z.string().describe("Object type to create (e.g. 'Permission', 'Service (unpublished)')."),
+    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 CreateProjectResultSchema = z
-    .object({ action: z.literal("create_project"), project: ProjectSchema.describe("The created project.") })
+    .object({
+    action: z.literal("create_project"),
+    project: ProjectSchema.describe("The created project."),
+    recommended_creation_order: z.array(RecommendedCreationOrderItemSchema).describe("Canonical deployment sequence satisfying dependency constraints. " +
+        "All industries share this base order; see IndustryMode.build_notes for industry-specific deviations."),
+    blueprint: z.object({
+        objects_count: z.number().describe("Number of draft objects created from the template."),
+        edges_count: z.number().describe("Number of graph edges from the template."),
+        industry_source: z.string().describe("Industry mode name that sourced the template."),
+        applied_template: z.string().describe("Template identifier applied."),
+        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>'."),
+    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)."),
+})
     .strict();
 const CreateProjectFromOnchainResultSchema = z
     .object({
@@ -395,8 +538,30 @@ const GetProjectDetailResultSchema = z
     .object({
     action: z.literal("get_project_detail"),
     project: ProjectSchema,
-    objects: z.array(ProjectObjectSchema).describe("Project objects (rigid relationships)."),
+    objects: z.array(ProjectObjectSchema).describe("Project objects (rigid relationships). Flat list — use objectGroups for role-based navigation."),
+    objectGroups: z.object({
+        core: z.array(ProjectObjectSchema).describe("Core objects (the Service) — the primary deliverable of the project."),
+        dependency: z.array(ProjectObjectSchema).describe("Dependency objects (Permission, Machine, Guard, Allocation, Treasury, etc.) — required for the Service to function."),
+        reference: z.array(ProjectObjectSchema).describe("Reference objects (read-only or external) — tracked but not owned by this project."),
+        other: z.array(ProjectObjectSchema).describe("Objects with invalid or missing role (data corruption, legacy data). Grouped here for visibility — should normally be empty. Check server logs for warnings."),
+        stats: z.object({
+            total: z.number().describe("Total object count."),
+            core_count: z.number().describe("Number of core objects."),
+            dependency_count: z.number().describe("Number of dependency objects."),
+            reference_count: z.number().describe("Number of reference objects."),
+            other_count: z.number().describe("Number of objects with invalid/missing role (in 'other' bucket). Normally 0."),
+            by_type: z.record(z.string(), z.number()).describe("Object count grouped by objectType prefix (e.g. {'service': 1, 'permission': 1, 'guard': 5})."),
+        }).strict().describe("Aggregate counts for quick project sizing."),
+    }).strict().describe("Objects grouped by role (core/dependency/reference/other) for easier navigation. The 'other' bucket captures objects with invalid roles (H-05 fix). The flat `objects` array is preserved for backward compatibility."),
     graphEdgeCount: z.number().describe("Number of persisted graph edges."),
+    serviceStatus: z
+        .object({
+        published: z.boolean().nullable().describe("Whether the on-chain Service is published (live). null = unknown / query failed."),
+        paused: z.boolean().nullable().describe("Whether the on-chain Service is paused (not accepting orders). null = unknown."),
+    })
+        .strict()
+        .nullable()
+        .describe("On-chain Service status (published / paused). Separate from the project's local lifecycle status. null if the project has no serviceAddress or the on-chain query failed."),
     evaluations: z
         .array(z.object({
         id: z.string(),
@@ -441,11 +606,39 @@ const CreateVersionResultSchema = z
 const BuildGraphResultSchema = z
     .object({
     action: z.literal("build_graph"),
-    nodeCount: z.number().describe("Total nodes in the constructed graph."),
-    edgeCount: z.number().describe("Total edges (after conflict resolution + dedup)."),
-    edgesBySource: z.record(z.string(), z.number()).describe("Edge counts by source: { internal: N, registrar: N, potential: N }."),
-    reputationCount: z.number().describe("Number of objects with Registrar reputation data."),
-    builtAt: z.number().describe("Build timestamp (ms)."),
+    async_mode: z.boolean().optional().describe("True when graph is building asynchronously (background task). When true, call query_task_status with task_id to retrieve the result."),
+    task_id: z.string().optional().describe("Async task id — present only when async_mode=true. Use with query_task_status."),
+    nodeCount: z.number().optional().describe("Total nodes in the constructed graph (sync mode only)."),
+    edgeCount: z.number().optional().describe("Total edges (after conflict resolution + dedup) (sync mode only)."),
+    edgesBySource: z.record(z.string(), z.number()).optional().describe("Edge counts by source: { internal: N, registrar: N, potential: N } (sync mode only)."),
+    reputationCount: z.number().optional().describe("Number of objects with Registrar reputation data (sync mode only)."),
+    builtAt: z.number().optional().describe("Build timestamp in ms (sync mode only)."),
+    binding_verification: z
+        .object({
+        service: z.string().describe("Service object address that was verified."),
+        bindings: z
+            .record(z.string(), z.object({
+            expected: z.string().describe("Expected target object type."),
+            actual: z.string().nullable().describe("Actual on-chain value (address or null)."),
+            count: z.number().optional().describe("Item count for array fields (order_allocators, arbitrations)."),
+            verified: z.boolean().describe("Whether the binding exists on-chain."),
+        }))
+            .describe("Per-field binding verification result."),
+        all_verified: z.boolean().describe("True when all critical bindings exist on-chain."),
+    })
+        .nullable()
+        .optional()
+        .describe("On-chain verification of Service bindings (F-15). Null when no Service address or query failed. Sync mode only."),
+    topEdges: z.array(z.object({
+        source: z.string().describe("Source object address."),
+        target: z.string().describe("Target object address."),
+        fieldName: z.string().nullable().describe("Field name on the source object (or null)."),
+        relationshipType: z.string().describe("Relationship type (bind, create, trigger, etc.)."),
+        weight: z.number().nullable().describe("Edge weight (0-1, higher = more important)."),
+        verified: z.boolean().describe("Whether the edge has been verified on-chain."),
+    }).strict()).optional().describe("Top 5 critical edges by weight (sync mode only). Preview of the most important relationships — call get_graph for the full list."),
+    visualization: z.string().optional().describe("Mermaid-style ASCII visualization of top edges (sync mode only). Compact format: 'source --field--> target'."),
+    hint: z.string().optional().describe("User-facing hint — guides to next action (e.g. call get_graph for full list, or query_task_status for async result)."),
 })
     .strict();
 const GetGraphResultSchema = z
@@ -550,10 +743,356 @@ const GenerateDeploymentDocResultSchema = z
             description: z.string(),
             status: z.enum(["PASS", "FAIL", "WARN"]),
             notes: z.string().optional(),
-        }).strict()).describe("D-01..D-18 check results."),
+        }).strict()).describe("D-01..D-20 check results (20 deployment checks including D-19 Machine entry-node forward and D-20 Service compensation_fund)."),
         errors: z.array(z.string()).describe("List of FAIL error messages."),
-    }).strict().describe("Deployment doc validation result against D-01..D-18."),
+    }).strict().describe("Deployment doc validation result against D-01..D-20."),
     saved: z.boolean().describe("Whether the markdown was persisted to SQLite project_documents table."),
+    detail_level: z.enum(["summary", "detailed", "full"]).describe("Effective detail level used to render the deployment doc. " +
+        "'summary' (default) shows only key bindings; 'detailed' adds sale/arbitration lists; 'full' shows complete config."),
+    stage_gate: z.object({
+        stage: z.number().describe("The stage that was validated (4 = deployment doc generation gate)."),
+        passed: z.boolean().describe("True iff no FAIL checks exist — gate allows advancing to Stage 5."),
+        can_proceed: z.boolean().describe("Alias for `passed` — whether the stage gate allows advancement."),
+        blocking_issues: z.array(z.string()).describe("FAIL status messages — must be resolved before deploying."),
+        warnings: z.array(z.string()).describe("WARN status messages — non-blocking, user may proceed at own risk."),
+        checks: z.array(z.object({
+            dimension: z.enum(["semantic", "tools", "reversibility", "risk", "isolation", "gas_budget"]).describe("The validation dimension."),
+            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 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)."),
+        warning_count: z.number().describe("Number of warning findings (non-blocking)."),
+        findings: z.array(z.object({
+            check_id: z.string().describe("D-XX check id (e.g. 'D-19') or sub-id (e.g. 'D-10a')."),
+            severity: z.enum(["critical", "warning", "info"]).describe("Finding severity."),
+            message: z.string().describe("Human-readable finding message."),
+            location: z.string().optional().describe("Document location (section, line, or step id)."),
+            suggestion: z.string().optional().describe("Suggested fix."),
+        }).strict()).describe("All findings from the 20 D-XX deployment checks."),
+        checks: z.object({
+            D01_object_defined: z.enum(["pass", "fail"]),
+            D02_dependency_complete: z.enum(["pass", "fail"]),
+            D03_scenario_covered: z.enum(["pass", "fail"]),
+            D04_testnet_topo_order: z.enum(["pass", "fail"]),
+            D05_testnet_network: z.enum(["pass", "fail"]),
+            D06_testnet_replace: z.enum(["pass", "fail"]),
+            D07_permission_index: z.enum(["pass", "fail"]),
+            D08_guard_gen_passport: z.enum(["pass", "fail"]),
+            D09_machine_node_count: z.enum(["pass", "fail"]),
+            D10_substep_coherence: z.enum(["pass", "fail"]),
+            D11_mainnet_testnet_match: z.enum(["pass", "fail"]),
+            D12_mainnet_network: z.enum(["pass", "fail"]),
+            D13_mainnet_replace: z.enum(["pass", "fail"]),
+            D14_testnet_verification: z.enum(["pass", "fail"]),
+            D15_mainnet_verification: z.enum(["pass", "fail"]),
+            D16_no_critical_risk: z.enum(["pass", "fail"]),
+            D17_no_high_risk: z.enum(["pass", "fail"]),
+            D18_completeness_checklist: z.enum(["pass", "fail"]),
+            D19_machine_entry_forward: z.enum(["pass", "fail"]).describe("Machine entry node (prev_node='') forwards non-empty — avoids Progress stuck at current=''."),
+            D20_service_compensation_fund: z.enum(["pass", "fail"]).describe("Service compensation_fund (Balance<T>) present or industry-exempt — ensures arbitration refund capability."),
+        }).strict().describe("Per-check pass/fail status for all 20 D-XX checks."),
+    }).strict().describe("Deployment scanner result — 20 D-XX checks including D-19 (Machine entry forward) and D-20 (Service compensation_fund)."),
+})
+    .strict();
+const PreEvaluateCheckResultSchema = z
+    .object({
+    action: z.literal("pre_evaluate_check"),
+    ready: z.boolean().describe("True if evaluate_project will produce meaningful results (no hard blockers). " +
+        "If false, address the items in `missing` first."),
+    missing: z.array(z.object({
+        id: z.string().describe("Check ID (e.g. PE-01, PE-06)."),
+        description: z.string().describe("What is missing."),
+        impact: z.string().describe("How it affects the evaluation, and how to fix it."),
+    }).strict()).describe("Hard blockers — must be resolved before evaluation."),
+    warnings: z.array(z.object({
+        id: z.string().describe("Check ID (e.g. PE-02, PE-03)."),
+        description: z.string().describe("What is suboptimal."),
+        impact: z.string().describe("How it affects the evaluation, and how to improve it."),
+    }).strict()).describe("Soft issues — evaluation runs but quality may be reduced."),
+    summary: z.string().describe("One-line human-readable status."),
+    counts: z.object({
+        objects: z.number().describe("Total project_objects count."),
+        edges: z.number().describe("Total graph_edges count."),
+        uncached: z.number().describe("Objects with no cached on-chain data."),
+        stale: z.number().describe("Objects with cache older than 24 hours."),
+        dangling_edges: z.number().describe("Edges referencing objects not in project_objects."),
+        drafts: z.number().describe("Objects still in draft (not yet on-chain)."),
+    }).strict().describe("Quick-scan counts for triage."),
+})
+    .strict();
+const VerifyDeploymentResultSchema = z
+    .object({
+    action: z.literal("verify_deployment"),
+    verifiedCount: z.number().describe("Number of objects actually verified (excludes drafts and unreachable)."),
+    matched: z.number().describe("Objects whose on-chain state matches SQLite."),
+    mismatched: z.number().describe("Objects whose on-chain state differs from SQLite (see `results[].differences`)."),
+    missing: z.number().describe("Objects that no longer exist on-chain (deleted or never deployed)."),
+    unreachable: z.number().describe("Objects that could not be queried (network error)."),
+    results: z.array(z.object({
+        objectAddress: z.string(),
+        objectName: z.string().nullable(),
+        objectType: z.string().nullable(),
+        status: z.enum(["matched", "mismatched", "missing", "unreachable"]).describe("Verification status: 'matched' = on-chain matches SQLite; " +
+            "'mismatched' = on-chain differs (see differences); " +
+            "'missing' = object no longer exists on-chain; " +
+            "'unreachable' = query failed (network error or rate limit)."),
+        differences: z.array(z.object({
+            field: z.string().describe("Field path that differs."),
+            sqlite: z.unknown().describe("Value recorded in SQLite."),
+            onchain: z.unknown().describe("Value observed on-chain."),
+        }).strict()).optional().describe("Per-field differences (only for status='mismatched')."),
+        bindings: z.object({
+            machine: z.boolean(),
+            permission: z.boolean(),
+            buy_guard: z.boolean(),
+            order_allocators: z.boolean(),
+        }).strict().optional().describe("Critical binding status (only for Service objects). " +
+            "Each boolean indicates whether the binding is set to a non-null value on-chain."),
+        error: z.string().optional().describe("Error message (only for status='unreachable')."),
+    }).strict()).describe("Per-object verification results."),
+    summary: z.string().describe("One-line human-readable summary."),
+})
+    .strict();
+const MachineGraphForwardSchema = z.object({
+    name: z.string().describe("Forward name."),
+    weight: z.number().describe("Forward weight (for weighted threshold)."),
+    guard: z.string().nullable().describe("Guard object address if the forward is guard-gated, else null."),
+    named_operator: z.string().nullable().describe("Named operator if set, else null."),
+    permission_index: z.number().nullable().describe("Permission index if set, else null."),
+}).strict();
+const MachineGraphEdgeSchema = z.object({
+    from: z.string().describe("Source node name (prev_node)."),
+    to: z.string().describe("Target node name (next_node)."),
+    threshold: z.number().describe("Minimum weighted forward count required to advance."),
+    forwards: z.array(MachineGraphForwardSchema).describe("Forwards within this pair — each is an advance operation."),
+}).strict();
+const MachineGraphNodeSchema = z.object({
+    name: z.string().describe("Node name."),
+    description: z.string().nullable().describe("Node description if set, else null."),
+}).strict();
+const GetMachineGraphResultSchema = z
+    .object({
+    action: z.literal("get_machine_graph"),
+    machineAddress: z.string().describe("The Machine object address."),
+    machineName: z.string().nullable().describe("The Machine's local name (from LocalMark) if available."),
+    nodes: z.array(MachineGraphNodeSchema).describe("Workflow nodes (states)."),
+    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
+    .object({
+    action: z.literal("clone_project_to_network"),
+    new_project_id: z.string().describe("The newly created project's UUID."),
+    new_prefix: z.string().describe("New project prefix ('<source_prefix>_<target_network>')."),
+    target_network: z.enum(["testnet", "mainnet"]).describe("The target network the new project is bound to."),
+    cloned_objects_count: z.number().describe("Number of object metadata entries copied (objectAddress is empty — await on-chain deployment)."),
+    message: z.string().describe("Human-readable summary of the clone operation."),
+    next_steps: z.string().describe("Instructions for deploying the cloned objects on the target network."),
+})
+    .strict();
+const MigrateNetworkResultSchema = z
+    .object({
+    action: z.literal("migrate_network"),
+    new_project_id: z.string().describe("The newly created project's UUID."),
+    new_prefix: z.string().describe("New project prefix ('<source_prefix>_<target_network>')."),
+    target_network: z.enum(["testnet", "mainnet"]).describe("The target network the new project is bound to."),
+    cloned_objects_count: z.number().describe("Number of object metadata entries copied (objectAddress is empty — await on-chain deployment)."),
+    message: z.string().describe("Human-readable summary of the migration operation."),
+    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();
 export const ProjectOperationOutputSchema = z
@@ -578,6 +1117,21 @@ export const ProjectOperationOutputSchema = z
         DeleteProjectResultSchema,
         AssembleContextResultSchema,
         GenerateDeploymentDocResultSchema,
+        PreEvaluateCheckResultSchema,
+        VerifyDeploymentResultSchema,
+        GetMachineGraphResultSchema,
+        GetGuardGraphResultSchema,
+        PlanObjectEditResultSchema,
+        ApplyObjectEditResultSchema,
+        PatchMachineNodesResultSchema,
+        PatchGuardTreeResultSchema,
+        CloneProjectToNetworkResultSchema,
+        MigrateNetworkResultSchema,
+        MigrateToMainnetResultSchema,
     ]).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();