@wowok/agent-mcp 2.5.5 → 2.6.1

package/dist/schemas/query_toolkit.schema.json

@@ -99,10 +99,6 @@
                   "type": "boolean",
                   "description": "Filter accounts with messenger enabled"
                 },
-                "m": {
-                  "$ref": "#/definitions/query_toolkit/anyOf/0/properties/filter/properties/name",
-                  "description": "Filter by messenger name (supports fuzzy match)"
-                },
                 "createdAt": {
                   "type": "object",
                   "properties": {
@@ -294,7 +290,7 @@
                 "testnet",
                 "mainnet"
               ],
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [
@@ -342,7 +338,7 @@
             },
             "network": {
               "$ref": "#/definitions/query_toolkit/anyOf/4/properties/network",
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [
@@ -371,7 +367,7 @@
             },
             "network": {
               "$ref": "#/definitions/query_toolkit/anyOf/4/properties/network",
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [
@@ -391,8 +387,8 @@
             "name_or_address": {
               "anyOf": [
                 {
-                  "type": "string",
-                  "description": "Account name, address (0x...), or mark name. When using string format, local marks are searched first. EXAMPLE: 'alice' - searches local marks first, then global; EXAMPLE: '0x1234...' - uses address directly"
+                  "$ref": "#/definitions/query_toolkit/anyOf/4/properties/name_or_address",
+                  "description": "Account name, address (0x...), or mark name. When using string format, local marks are searched first. EXAMPLE: 'alice' - searches local marks first, then global; EXAMPLE: '0x2...' (64 hex chars) - uses address directly; EXAMPLE: '' - uses the default local account"
                 },
                 {
                   "type": "object",
@@ -447,7 +443,7 @@
             },
             "network": {
               "$ref": "#/definitions/query_toolkit/anyOf/4/properties/network",
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [
@@ -474,7 +470,7 @@
             },
             "network": {
               "$ref": "#/definitions/query_toolkit/anyOf/4/properties/network",
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [
@@ -523,7 +519,7 @@
             },
             "network": {
               "$ref": "#/definitions/query_toolkit/anyOf/4/properties/network",
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [
@@ -579,7 +575,7 @@
             },
             "network": {
               "$ref": "#/definitions/query_toolkit/anyOf/4/properties/network",
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [

package/dist/schemas/schema_query.output.json

@@ -46,14 +46,14 @@
             {
               "type": "object",
               "additionalProperties": {},
-              "description": "JSON Schema object (get/get_output)."
+              "description": "JSON Schema object (get/get_output/get_field) or Guard template data."
             },
             {
               "type": "null",
-              "description": "No data — lookup failed or returned nothing."
+              "description": "No data — lookup failed or returned nothing, or data was written to output_file."
             }
           ],
-          "description": "Response data — array of schema summaries for list-like actions, JSON Schema object for get/get_output, null on failure."
+          "description": "Response data — array of schema summaries for list-like actions, JSON Schema object for get/get_output/get_field, Guard template data for get_guard_templates, null on failure or when output_file is used."
         },
         "message": {
           "type": "string",
@@ -65,6 +65,10 @@
             "type": "string"
           },
           "description": "Suggested next steps or alternatives"
+        },
+        "output_file_path": {
+          "type": "string",
+          "description": "When output_file is used, contains the absolute file path where data was written."
         }
       },
       "required": [

package/dist/schemas/schema_query.schema.json

@@ -15,17 +15,31 @@
             "get",
             "get_output",
             "search",
-            "list_operations"
+            "list_operations",
+            "get_guard_templates",
+            "get_field"
           ],
-          "description": "Action to perform: 'list' to see all available schemas, 'get' to retrieve a specific input schema, 'get_output' to retrieve a tool's output schema, 'search' to find schemas by keyword, 'list_operations' to list all on-chain operations"
+          "description": "Action to perform: 'list' (all schemas), 'get' (specific input schema), 'get_output' (tool output schema), 'get_field' (field-path query e.g. field_path='data.node'), 'search' (by keyword), 'list_operations' (on-chain operations), 'get_guard_templates' (Guard creation templates + best practices)."
         },
         "name": {
           "type": "string",
-          "description": "Schema/tool name for 'get'/'get_output' action (e.g., 'onchain_operations', 'account_operation', 'onchain_operations_permission')"
+          "description": "Schema/tool name for 'get'/'get_output'/'get_field' action (e.g., 'onchain_operations', 'onchain_operations_machine')."
         },
         "query": {
           "type": "string",
           "description": "Search query for 'search' action"
+        },
+        "field_path": {
+          "type": "string",
+          "description": "Dot-separated field path for 'get_field' action (e.g. 'data.node', 'data.node.nodes.0.pairs'). Navigates schema.properties.* and schema.items.*."
+        },
+        "template": {
+          "type": "string",
+          "description": "Guard template name for 'get_guard_templates' action. Omit to list all available templates. Available: signer_verification, progress_node_check, order_owner_verification, service_belonging_check, reward_not_claimed, combined_reward_guard."
+        },
+        "output_file": {
+          "type": "string",
+          "description": "When set, writes the response data to this file path (relative to cwd) and returns the path instead of inline data. Use for large schemas that would be truncated. Prefer workspace paths like '.trae/tmp/schema.json' so the Read tool can access them."
         }
       },
       "required": [

package/dist/telemetry/storage.js

@@ -1,8 +1,8 @@
 import { mkdir, appendFile, stat, rename } from "fs/promises";
 import { dirname, join } from "path";
-import { homedir } from "os";
+import { getWowMcpDir } from "@wowok/wowok";
 const MAX_SIZE_BYTES = 10 * 1024 * 1024;
-const DATA_DIR = join(homedir(), ".wowok", "data");
+const DATA_DIR = join(getWowMcpDir(), "data");
 const TELEMETRY_FILE = join(DATA_DIR, "telemetry.jsonl");
 const ROTATED_FILE = join(DATA_DIR, "telemetry.jsonl.1");
 class JsonlStorage {

package/dist/tools/handlers/local.js

@@ -1,4 +1,5 @@
 import { wrapLocalHandler } from "../shared.js";
+import { withFaucetRetry } from "../retry.js";
 import { AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, } from "../../schema/index.js";
 import { account_operation, local_mark_operation, local_info_operation, } from "@wowok/wowok";
 function deriveOpType(prefix, validated) {
@@ -11,7 +12,7 @@ function deriveOpType(prefix, validated) {
 }
 export const handleAccountOperation = wrapLocalHandler({
     schema: AccountOperationSchema,
-    operationFn: account_operation,
+    operationFn: withFaucetRetry(account_operation),
     parseLabel: "account_operation input",
     buildContext: (validated) => ({
         operation_type: deriveOpType("account", validated),
@@ -22,10 +23,24 @@ export const handleMarkOperation = wrapLocalHandler({
     schema: LocalMarkOperationSchema,
     operationFn: local_mark_operation,
     parseLabel: "local_mark_operation input",
-    buildContext: (validated) => ({
-        operation_type: deriveOpType("mark", validated),
-        data: validated,
-    }),
+    buildContext: (validated) => {
+        const ctx = {
+            operation_type: deriveOpType("mark", validated),
+            data: validated,
+        };
+        const v = validated;
+        if (v.add && Array.isArray(v.add.data) && v.add.data.length > 0) {
+            ctx.pre_warnings = [
+                "Cross-network consistency (FIX-011): LocalMark names are scoped per network. " +
+                    "When creating marks for the same logical object on different networks " +
+                    "(e.g. testnet and mainnet), use the SAME name value to keep name-based " +
+                    "references portable. Before creating a mark on mainnet, consider querying " +
+                    "testnet via query_local with network='testnet' to check for an existing " +
+                    "same-named mark and replicate it.",
+            ];
+        }
+        return ctx;
+    },
 });
 export const handleInfoOperation = wrapLocalHandler({
     schema: LocalInfoOperationSchema,

package/dist/tools/handlers/onchain.js

@@ -81,6 +81,15 @@ export async function handleOnchainOperations(args) {
             validated.data = pn.data;
             projectWarnings = pn.warnings ?? [];
         }
+        if (!env.account && projectEnvPrefix) {
+            try {
+                const project = await LocalProject.Instance().getProjectByPrefix(projectEnvPrefix);
+                if (project?.defaultAccount) {
+                    env.account = project.defaultAccount;
+                }
+            }
+            catch { }
+        }
         delete env.confirmed;
         delete env.user_intent_phrases;
         delete env.project;
@@ -94,6 +103,15 @@ export async function handleOnchainOperations(args) {
                     : await callService.call(env);
                 const data = validated.data;
                 const intent = data?.publish ? "publish service" : data?.bPublished !== undefined ? "modify service" : "create service";
+                const isCreatingService = data?.object != null && typeof data.object === "object";
+                const hasCompensationFundAdd = data?.compensation_fund_add != null;
+                if (isCreatingService && !hasCompensationFundAdd) {
+                    constraintWarnings.push("Service.compensation_fund balance is 0 — no refund protection for buyers. " +
+                        "If buyers need refund protection, call service.compensation_fund_add with a Coin<T> " +
+                        "to deposit. Without deposit, arbitration rulings cannot withdraw compensation " +
+                        "from this Service. (Note: some industries like freelance do not require this; " +
+                        "the evaluation engine will check industry-specific requirements.)");
+                }
                 const output = handleCallResult(result, withHarness(buildCtx(data), "service", intent));
                 autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
                 return output;
@@ -132,6 +150,13 @@ export async function handleOnchainOperations(args) {
                 return output;
             }
             case "progress": {
+                if (validated.data?.operate) {
+                    constraintWarnings.push("Progress routing hint: if this Progress is bound to an Order and the target " +
+                        "Forward uses namedOperator=\"\" (empty string = OrderHolder), use " +
+                        "order.progress (NOT progress.operate). Direct progress::next fails with " +
+                        "Permission denied for OrderHolder forwards. Use progress.operate only for " +
+                        "non-empty namedOperator or permissionIndex-only forwards.");
+                }
                 const callProgress = new CallProgress(validated.data);
                 const result = validated.submission
                     ? await callProgress.call_with_submission(env, await transformSubmission(validated.submission))
@@ -281,6 +306,17 @@ export async function handleOnchainOperations(args) {
                 return output;
             }
             case "order": {
+                if (validated.data?.progress) {
+                    constraintWarnings.push("Order routing hint: order.progress works only for Forwards with " +
+                        "namedOperator=\"\" (OrderHolder). If the target Forward uses a " +
+                        "non-empty namedOperator or permissionIndex-only, use progress.operate " +
+                        "on the Progress object directly instead.");
+                    constraintWarnings.push("Allocation hint: if this operation advances the order to a terminal " +
+                        "state (e.g. Completed/Cancelled/Refunded), funds remain in the " +
+                        "Allocation object and are NOT auto-distributed. To release funds, " +
+                        "trigger the corresponding Guard verification via allocation operation " +
+                        "(the Guard bound to the matching Allocator will verify and distribute).");
+                }
                 const callOrder = new CallOrder(validated.data);
                 const result = validated.submission
                     ? await callOrder.call_with_submission(env, await transformSubmission(validated.submission))

package/dist/tools/handlers/project.js

@@ -1,7 +1,12 @@
 import { assembleContext } from "../../project/context-assembly.js";
-import { handleListProjects, handleCreateProject, handleCreateProjectFromOnchain, handleUpdateProject, handleGetProjectDetail, handleAddObject, handleRemoveObject, handleUpdateObject, handleCreateVersion, handleBuildGraph, handleGetGraph, handleEvaluateProject, handleSaveEvaluation, handleCompareProjects, handleRefreshObjects, handleGetObjectDiff, handleDeleteProject, } from "../../project/handlers.js";
+import { generateDeploymentDocFromProject } from "../../project/deployment-bridge.js";
+import { LocalProject } from "@wowok/wowok";
+import { validateStageGate } from "../../project/stage-gate.js";
+import { scanDeployment } from "../../knowledge/deployment-scanner.js";
+import { handleListProjects, handleCreateProject, handleCreateProjectFromOnchain, handleUpdateProject, handleGetProjectDetail, handleAddObject, handleRemoveObject, handleUpdateObject, handleCreateVersion, handleBuildGraph, handleGetGraph, handleEvaluateProject, handleSaveEvaluation, handleCompareProjects, handleRefreshObjects, handleGetObjectDiff, handleDeleteProject, handleGetMachineGraph, handlePreEvaluateCheck, handleVerifyDeployment, handleCloneProjectToNetwork, } from "../../project/handlers.js";
 import { strictParse } from "../../schema/index.js";
 import { ProjectOperationInputSchema } from "../../schema/project/index.js";
+import { getStageCache } from "../../project/index.js";
 export async function handleProjectOperation(args) {
     const validated = strictParse(ProjectOperationInputSchema, args, "project_operation input");
     const { action } = validated;
@@ -58,9 +63,75 @@ export async function handleProjectOperation(args) {
         case "delete_project":
             result = await handleDeleteProject(validated);
             break;
+        case "get_machine_graph":
+            result = await handleGetMachineGraph(validated);
+            break;
         case "assemble_context":
             result = await assembleContext(validated);
             break;
+        case "generate_deployment_doc": {
+            const { project_id, network, save = true, detail_level } = validated;
+            if (!project_id) {
+                throw new Error("'project_id' is required for generate_deployment_doc");
+            }
+            if (!network) {
+                throw new Error("'network' is required for generate_deployment_doc");
+            }
+            const genResult = await generateDeploymentDocFromProject(project_id, network, detail_level);
+            if (save) {
+                await LocalProject.Instance().saveDocument(project_id, network, genResult.markdown);
+            }
+            const project = await LocalProject.Instance().getProject(project_id);
+            const stageEntry = getStageCache(project?.prefix ?? project_id, project?.currentVersion ?? "v1");
+            const stageGateResult = validateStageGate({
+                stage: 4,
+                prefix: project?.prefix ?? project_id,
+                version: project?.currentVersion ?? "v1",
+                objects: [],
+                risk_status: stageEntry?.risk_status,
+                risk_can_proceed: stageEntry?.risk_can_proceed,
+                has_published_object: false,
+                deployment_doc_generated: true,
+            });
+            const scanResult = scanDeployment({
+                project_name: project?.prefix ?? project_id,
+            });
+            result = {
+                action: "generate_deployment_doc",
+                markdown: genResult.markdown,
+                validation: genResult.validation,
+                saved: save,
+                detail_level: detail_level ?? "summary",
+                stage_gate: {
+                    stage: stageGateResult.stage,
+                    passed: stageGateResult.passed,
+                    can_proceed: stageGateResult.can_proceed,
+                    blocking_issues: stageGateResult.blocking_issues,
+                    warnings: stageGateResult.warnings,
+                    checks: stageGateResult.checks,
+                },
+                deployment_scan: {
+                    overall_readiness: scanResult.overall_readiness,
+                    critical_count: scanResult.findings.filter(f => f.severity === "critical").length,
+                    warning_count: scanResult.findings.filter(f => f.severity === "warning").length,
+                    findings: scanResult.findings,
+                    checks: scanResult.checks,
+                },
+            };
+            break;
+        }
+        case "pre_evaluate_check":
+            result = await handlePreEvaluateCheck(validated);
+            break;
+        case "verify_deployment":
+            result = await handleVerifyDeployment(validated);
+            break;
+        case "clone_project_to_network":
+            result = await handleCloneProjectToNetwork(validated);
+            break;
+        case "migrate_network":
+            result = await handleCloneProjectToNetwork(validated);
+            break;
         default:
             throw new Error(`Unknown project_operation action: ${String(action)}`);
     }

package/dist/tools/handlers/query.js

@@ -73,6 +73,33 @@ export async function handleWatchQueryOperations(args) {
                     }
                     return obj;
                 });
+                queryResult.objects = queryResult.objects.map((obj) => {
+                    if (obj && obj.data && obj.data.type === "Progress" && obj.data.current === "") {
+                        const machineId = obj.data.machine;
+                        const taskId = obj.data.task;
+                        return {
+                            ...obj,
+                            _diagnostic: {
+                                issue: "Progress.current is empty — order workflow is stuck at the initial state",
+                                cause: "The Machine's entry node (prev_node='') likely has no forwards defined. " +
+                                    "When Progress starts, it looks up the entry node's forwards to determine " +
+                                    "the next node. Without forwards, Progress cannot advance and the order " +
+                                    "is permanently stuck.",
+                                machine_object_id: machineId ?? null,
+                                bound_order_id: taskId ?? null,
+                                fix: [
+                                    "1. Query the Machine object (use query_toolkit with query_type='onchain_objects' and objects=[" + JSON.stringify(machineId) + "]).",
+                                    "2. Inspect node.pairs for the entry node (prev_node='').",
+                                    "3. If forwards is empty: this is the root cause. The Machine must be republished with at least one forward on the entry node.",
+                                    "4. To republish: clone the Machine nodes, add a forward to the entry node's pairs, then create a new Machine (Machine nodes are immutable after publish — see P0-2 schema validation that now blocks this).",
+                                    "5. Rebind the new Machine to the Service (service.machine field) and create a new Order to test.",
+                                ],
+                                reference: "P0-2 schema refinement in MachineNodePairSchema ensures new Machines cannot be published with empty entry-node forwards. This diagnostic catches legacy Machines that predate the fix.",
+                            },
+                        };
+                    }
+                    return obj;
+                });
             }
             result = { query_type: "onchain_objects", result: queryResult };
             break;

package/dist/tools/handlers/schema-query.js

@@ -7,9 +7,16 @@ export async function handleSchemaQuery(args) {
         action: validated.action,
         name: validated.name,
         query: validated.query,
+        field_path: validated.field_path,
+        template: validated.template,
+        output_file: validated.output_file,
     };
     const response = processSchemaQuery(request);
     let textContent = response.message;
+    if (response.output_file_path) {
+        textContent += `\n\n📄 Full data written to: ${response.output_file_path}`;
+        textContent += `\n   Use the Read tool to access the file content.`;
+    }
     const data = response.data;
     if (response.success && data) {
         switch (request.action) {
@@ -55,6 +62,18 @@ export async function handleSchemaQuery(args) {
                 textContent += JSON.stringify(data, null, 2);
                 textContent += "\n```\n";
                 break;
+            case "get_guard_templates":
+                textContent += "\n\n## Guard Templates\n\n";
+                textContent += "```json\n";
+                textContent += JSON.stringify(data, null, 2);
+                textContent += "\n```\n";
+                break;
+            case "get_field":
+                textContent += "\n\n## Field Schema\n\n";
+                textContent += "```json\n";
+                textContent += JSON.stringify(data, null, 2);
+                textContent += "\n```\n";
+                break;
             case "search":
                 if (Array.isArray(data) && data.length > 0) {
                     textContent += `\n\nFound ${data.length} schemas matching '${request.query ?? ""}':\n`;

package/dist/tools/handlers/task-status.d.ts

@@ -0,0 +1,170 @@
+import { z } from "zod";
+import type { ToolDispatchResult } from "../types.js";
+export declare const QueryTaskStatusInputSchema: z.ZodObject<{
+    task_id: z.ZodOptional<z.ZodString>;
+    project_id: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    project_id?: string | undefined;
+    task_id?: string | undefined;
+}, {
+    project_id?: string | undefined;
+    task_id?: string | undefined;
+}>;
+export declare const TaskStateSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    operation: z.ZodString;
+    status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+    progress: z.ZodNumber;
+    message: z.ZodString;
+    result: z.ZodNullable<z.ZodUnknown>;
+    error: z.ZodNullable<z.ZodString>;
+    started_at: z.ZodNumber;
+    completed_at: z.ZodNullable<z.ZodNumber>;
+    project_id: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    status: "failed" | "completed" | "pending" | "cancelled" | "running";
+    error: string | null;
+    operation: string;
+    progress: number;
+    completed_at: number | null;
+    project_id: string | null;
+    task_id: string;
+    started_at: number;
+    result?: unknown;
+}, {
+    message: string;
+    status: "failed" | "completed" | "pending" | "cancelled" | "running";
+    error: string | null;
+    operation: string;
+    progress: number;
+    completed_at: number | null;
+    project_id: string | null;
+    task_id: string;
+    started_at: number;
+    result?: unknown;
+}>;
+export declare const QueryTaskStatusOutputSchema: z.ZodObject<{
+    task_id: z.ZodOptional<z.ZodString>;
+    task: z.ZodNullable<z.ZodObject<{
+        task_id: z.ZodString;
+        operation: z.ZodString;
+        status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+        progress: z.ZodNumber;
+        message: z.ZodString;
+        result: z.ZodNullable<z.ZodUnknown>;
+        error: z.ZodNullable<z.ZodString>;
+        started_at: z.ZodNumber;
+        completed_at: z.ZodNullable<z.ZodNumber>;
+        project_id: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }, {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }>>;
+    tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        task_id: z.ZodString;
+        operation: z.ZodString;
+        status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+        progress: z.ZodNumber;
+        message: z.ZodString;
+        result: z.ZodNullable<z.ZodUnknown>;
+        error: z.ZodNullable<z.ZodString>;
+        started_at: z.ZodNumber;
+        completed_at: z.ZodNullable<z.ZodNumber>;
+        project_id: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }, {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    task: {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    } | null;
+    task_id?: string | undefined;
+    tasks?: {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }[] | undefined;
+}, {
+    task: {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    } | null;
+    task_id?: string | undefined;
+    tasks?: {
+        message: string;
+        status: "failed" | "completed" | "pending" | "cancelled" | "running";
+        error: string | null;
+        operation: string;
+        progress: number;
+        completed_at: number | null;
+        project_id: string | null;
+        task_id: string;
+        started_at: number;
+        result?: unknown;
+    }[] | undefined;
+}>;
+export declare function handleQueryTaskStatus(args: unknown): Promise<ToolDispatchResult>;