@wowok/agent-mcp 2.6.1 → 2.6.3

package/dist/project/evaluation.js

@@ -1,4 +1,5 @@
 import { IndustryModeRegistry } from "../extensions/registry.js";
+import { collectPermissionIndexes, checkPermissionAuthorization, } from "../schema/utils/permission-machine-check.js";
 const CRITICAL_BINDINGS = [
     { sourceType: "Service", targetType: "Machine", fieldName: "machine", critical: true },
     { sourceType: "Service", targetType: "Permission", fieldName: "permission", critical: true },
@@ -21,7 +22,7 @@ const MERCHANT_REQUIRED_ITEMS = [
     { id: "R11", objectType: "Repository", fieldName: "repositories", required: false, description: "Documentation — published data" },
     { id: "R12", objectType: "Demand", fieldName: "", required: false, description: "Market discovery — demand signals" },
 ];
-function resolveRequiredItems(industry, compensationFundBalance = 0) {
+function resolveRequiredItems(industry, compensationFundBalance = 0, hasAllocationEscrow = false) {
     let result = MERCHANT_REQUIRED_ITEMS;
     if (industry && industry !== "general") {
         let mode;
@@ -42,6 +43,14 @@ function resolveRequiredItems(industry, compensationFundBalance = 0) {
             }
         }
     }
+    if (hasAllocationEscrow && compensationFundBalance === 0) {
+        result = result.map(item => {
+            if (item.id === "R6") {
+                return { ...item, required: false };
+            }
+            return item;
+        });
+    }
     if (compensationFundBalance > 0) {
         result = result.map(item => item.id === "R7" ? { ...item, required: true } : item);
     }
@@ -130,6 +139,26 @@ export function getMachineNodeCount(data) {
     }
     return 0;
 }
+function extractMachineNodesFromCache(data) {
+    if (!data)
+        return [];
+    const nodesArr = data["nodes"];
+    if (Array.isArray(nodesArr)) {
+        return nodesArr;
+    }
+    const config = data["config"];
+    if (config && Array.isArray(config["nodes"])) {
+        return config["nodes"];
+    }
+    const nodesObj = data["nodes"];
+    if (nodesObj && typeof nodesObj === "object") {
+        const fieldsObj = nodesObj["fields"];
+        if (fieldsObj && Array.isArray(fieldsObj["contents"])) {
+            return fieldsObj["contents"];
+        }
+    }
+    return [];
+}
 function getBalanceValue(data, field) {
     if (!data)
         return 0;
@@ -192,7 +221,7 @@ function getMaxSalePrice(data) {
     }
     return max;
 }
-function detectCircularRefs(edges) {
+function detectCircularRefs(edges, objectTypeMap) {
     const adj = new Map();
     for (const e of edges) {
         if (e.edgeSource === "potential")
@@ -239,12 +268,45 @@ function detectCircularRefs(edges) {
             else if (recursionStack.has(neighbor)) {
                 const cycleStart = path.indexOf(neighbor);
                 const cycle = path.slice(cycleStart).concat(neighbor);
-                cycles.push(cycle.join("→"));
+                if (!isWoWokNormalFundCycle(cycle, objectTypeMap)) {
+                    cycles.push(cycle.join("→"));
+                }
             }
         }
     }
     return cycles;
 }
+function isWoWokNormalFundCycle(cycle, objectTypeMap) {
+    if (!objectTypeMap || cycle.length < 3)
+        return false;
+    const typesInCycle = new Set();
+    for (const addr of cycle) {
+        const type = objectTypeMap.get(addr);
+        if (type) {
+            typesInCycle.add(type);
+        }
+        else {
+            return false;
+        }
+    }
+    if (typesInCycle.size === 2 &&
+        typesInCycle.has("Order") &&
+        typesInCycle.has("Allocation")) {
+        return true;
+    }
+    if (typesInCycle.size === 3 &&
+        typesInCycle.has("Order") &&
+        typesInCycle.has("Allocation") &&
+        typesInCycle.has("Payment")) {
+        return true;
+    }
+    const workflowTypes = ["Service", "Machine", "Progress", "Order"];
+    const isWorkflowCycle = Array.from(typesInCycle).every(t => workflowTypes.includes(t));
+    if (isWorkflowCycle && typesInCycle.size >= 2) {
+        return true;
+    }
+    return false;
+}
 function adjustWeightsForPerspective(criterionScores, perspective) {
     if (perspective === "consumer") {
         return criterionScores.map(c => {
@@ -334,7 +396,7 @@ function evaluateIndustryPattern(project, objects, objectCache, edges) {
         if (machines.length > 0) {
             const machineObj = machines[0];
             const cached = parseCacheData(objectCache.get(machineObj.objectAddress));
-            const nodeCount = getNumberField(cached, "node_count") || countArrayField(cached ?? {}, "nodes");
+            const nodeCount = getMachineNodeCount(cached);
             if (nodeCount > 0 && nodeCount >= expectedNodes.length) {
                 matchCount++;
                 result.strengths.push(`Industry pattern match: Machine has ${nodeCount} nodes, covering "${industryName}" mode's ${expectedNodes.length} expected node(s)`);
@@ -444,6 +506,28 @@ function evaluateIndustryPattern(project, objects, objectCache, edges) {
             deduction: 0,
         });
     }
+    if (industryName === "freelance") {
+        const machines = byType.get("Machine") ?? [];
+        for (const m of machines) {
+            const mData = parseCacheData(objectCache.get(m.objectAddress));
+            if (!mData)
+                continue;
+            const nodeCount = getMachineNodeCount(mData);
+            if (nodeCount > 0) {
+                result.findings.push({
+                    criterion: "industry_pattern",
+                    severity: "info",
+                    message: `ISSUE-P1-4: freelance project has a Machine with ${nodeCount} node(s). ` +
+                        `If the workflow includes a "delivered" state, 48h auto-accept requires ` +
+                        `an off-chain keeper (WoWok Guard does not support time-based triggers). ` +
+                        `Keeper should poll Progress objects in "delivered" state and call ` +
+                        `adminUnhold (permission 224) after 48h timeout.`,
+                    deduction: 0,
+                });
+                break;
+            }
+        }
+    }
     return result;
 }
 function evaluateRisk(input) {
@@ -499,8 +583,13 @@ function evaluateRisk(input) {
     structuralScore = clampScore(structuralScore);
     let fundScore = 100;
     const treasuries = byType.get("Treasury") ?? [];
+    const allocations = byType.get("Allocation") ?? [];
     const serviceData = serviceObj ? parseCacheData(objectCache.get(serviceObj.objectAddress)) : null;
     const compensationBalance = serviceObj ? getBalanceValue(serviceData, "compensation_fund") : 0;
+    const orderAllocatorsBinding = serviceObj
+        ? bindingIndex.get(`${serviceObj.objectAddress}#order_allocators`)?.size ?? 0
+        : 0;
+    const hasAllocationEscrow = allocations.length > 0 && orderAllocatorsBinding > 0;
     let industryRequiresFund = true;
     if (project.industry && project.industry !== "general") {
         try {
@@ -512,7 +601,17 @@ function evaluateRisk(input) {
         catch { }
     }
     if (treasuries.length === 0 && compensationBalance === 0) {
-        if (industryRequiresFund) {
+        if (hasAllocationEscrow) {
+            fundScore -= 5;
+            strengths.push("Allocation escrow mode active — funds locked in contract, released by Guard verification");
+            findings.push({
+                criterion: "fund_safety",
+                severity: "info",
+                message: `Using Allocation escrow (${allocations.length} Allocation object(s) + order_allocators bound) — fund safety via Guard verification, no Treasury/compensation_fund needed`,
+                deduction: -5,
+            });
+        }
+        else if (industryRequiresFund) {
             fundScore -= 30;
             findings.push({
                 criterion: "fund_safety",
@@ -539,13 +638,23 @@ function evaluateRisk(input) {
             strengths.push(`Service.compensation_fund has ${compensationBalance} units — inline refund fund active`);
             const maxSalePrice = getMaxSalePrice(serviceData);
             if (maxSalePrice > 0) {
-                const requiredThreshold = 5 * maxSalePrice;
+                let coverageRatio = 5;
+                if (project.industry && project.industry !== "general") {
+                    try {
+                        const mode = IndustryModeRegistry.Instance().getMode(project.industry);
+                        if (mode?.risk_constraints?.compensation_fund_coverage_ratio) {
+                            coverageRatio = mode.risk_constraints.compensation_fund_coverage_ratio;
+                        }
+                    }
+                    catch { }
+                }
+                const requiredThreshold = coverageRatio * maxSalePrice;
                 if (compensationBalance < requiredThreshold) {
                     fundScore -= 10;
                     findings.push({
                         criterion: "fund_safety",
                         severity: "warning",
-                        message: `Service.compensation_fund balance (${compensationBalance}) is less than 5× the max order amount (${maxSalePrice} → threshold ${requiredThreshold}). Refund coverage may be insufficient — top up via service.compensation_fund_add to avoid arbitration rulings exceeding the fund.`,
+                        message: `Service.compensation_fund balance (${compensationBalance}) is less than ${coverageRatio}× the max order amount (${maxSalePrice} → threshold ${requiredThreshold}). Refund coverage may be insufficient — top up via service.compensation_fund_add to avoid arbitration rulings exceeding the fund. (industry: ${project.industry ?? "general"}, ratio: ${coverageRatio}×)`,
                         deduction: -10,
                     });
                 }
@@ -553,7 +662,7 @@ function evaluateRisk(input) {
                     findings.push({
                         criterion: "fund_safety",
                         severity: "info",
-                        message: `Service.compensation_fund balance (${compensationBalance}) covers 5× the max order amount (${maxSalePrice}). Fund is sufficient for refund protection.`,
+                        message: `Service.compensation_fund balance (${compensationBalance}) covers ${coverageRatio}× the max order amount (${maxSalePrice}). Fund is sufficient for refund protection. (industry: ${project.industry ?? "general"}, ratio: ${coverageRatio}×)`,
                         deduction: 0,
                     });
                 }
@@ -632,6 +741,160 @@ function evaluateRisk(input) {
             });
         }
     }
+    const machines = byType.get("Machine") ?? [];
+    for (const machineObj of machines) {
+        const meta = machineObj.metadata;
+        const config = meta?.config;
+        if (config?.entry_node_forward_hint) {
+            const hint = config.entry_node_forward_hint;
+            const exampleFwd = hint.example_forward;
+            if (exampleFwd?.namedOperator === "") {
+                strengths.push("Machine entry forward uses namedOperator='' (OrderHolder) — " +
+                    "correct for customer-operable nodes. namedOperator='' represents " +
+                    "the order holder, distinct from merchant's permission index.");
+            }
+        }
+        const guardObjects = config?.guard_objects;
+        if (guardObjects && guardObjects.length > 0) {
+            strengths.push(`Machine has ${guardObjects.length} guard object reference(s) — ` +
+                `forward-level permission validation configured`);
+        }
+        const cached = parseCacheData(objectCache.get(machineObj.objectAddress));
+        const nodeCount = getMachineNodeCount(cached);
+        if (nodeCount > 0 && !config) {
+            findings.push({
+                criterion: "governance_risk",
+                severity: "info",
+                message: `Machine has ${nodeCount} node(s). Verify each forward has at least one of ` +
+                    `namedOperator or permissionIndex. Key: namedOperator='' means OrderHolder ` +
+                    `(customer), NOT 'anyone'. Use non-empty namedOperator for specific roles, ` +
+                    `or permissionIndex for permission-based access. Both set = OR semantic ` +
+                    `(either can execute).`,
+                deduction: 0,
+            });
+        }
+    }
+    const machinesForPermCheck = byType.get("Machine") ?? [];
+    const permissionsForCheck = byType.get("Permission") ?? [];
+    const permDataMap = new Map();
+    for (const permObj of permissionsForCheck) {
+        const cached = parseCacheData(objectCache.get(permObj.objectAddress));
+        if (cached) {
+            permDataMap.set(permObj.objectAddress, {
+                address: permObj.objectAddress,
+                entity_count: typeof cached.entity_count === "number" ? cached.entity_count : undefined,
+                perm_remark: Array.isArray(cached.perm_remark) ? cached.perm_remark : undefined,
+                owner: typeof cached.owner === "string" ? cached.owner : (typeof cached.builder === "string" ? cached.builder : undefined),
+                admin: Array.isArray(cached.admin) ? cached.admin : undefined,
+            });
+        }
+    }
+    for (const machineObj of machinesForPermCheck) {
+        const machinePermKey = `${machineObj.objectAddress}#permission`;
+        const machinePermBindings = bindingIndex.get(machinePermKey);
+        if (!machinePermBindings || machinePermBindings.size === 0)
+            continue;
+        let permAddress = null;
+        for (const addr of machinePermBindings) {
+            permAddress = addr;
+            break;
+        }
+        if (!permAddress)
+            continue;
+        const permData = permDataMap.get(permAddress);
+        if (!permData)
+            continue;
+        const machineCached = parseCacheData(objectCache.get(machineObj.objectAddress));
+        if (!machineCached)
+            continue;
+        const machineNodes = extractMachineNodesFromCache(machineCached);
+        if (machineNodes.length === 0)
+            continue;
+        const collection = collectPermissionIndexes(machineNodes);
+        if (collection.requiredIndexes.length === 0)
+            continue;
+        const report = checkPermissionAuthorization(collection.requiredIndexes, permData);
+        if (!report.allAuthorized) {
+            governanceScore -= 25;
+            findings.push({
+                criterion: "governance_risk",
+                severity: "critical",
+                message: `Machine ${machineObj.objectAddress.slice(0, 8)} has forwards referencing ` +
+                    `un-authorized permission indexes: [${report.missingIndexes.join(", ")}]. ` +
+                    `These forwards can NEVER be executed — Progress will be permanently stuck. ` +
+                    `Grant entities for these indexes via permission.op="add perm by index" ` +
+                    `before publishing the Machine.`,
+                deduction: -25,
+            });
+        }
+        else {
+            strengths.push(`Machine ${machineObj.objectAddress.slice(0, 8)}: all ${collection.requiredIndexes.length} ` +
+                `permission index(es) are authorized`);
+        }
+    }
+    if (serviceObj && arbitrations.length > 0) {
+        const svcPermKey = `${serviceObj.objectAddress}#permission`;
+        const svcPermBindings = bindingIndex.get(svcPermKey);
+        const svcPermAddress = svcPermBindings && svcPermBindings.size > 0
+            ? Array.from(svcPermBindings)[0]
+            : null;
+        const svcPermData = svcPermAddress ? permDataMap.get(svcPermAddress) : null;
+        for (const arbObj of arbitrations) {
+            const arbPermKey = `${arbObj.objectAddress}#permission`;
+            const arbPermBindings = bindingIndex.get(arbPermKey);
+            const arbPermAddress = arbPermBindings && arbPermBindings.size > 0
+                ? Array.from(arbPermBindings)[0]
+                : null;
+            if (!svcPermAddress || !arbPermAddress)
+                continue;
+            if (svcPermAddress === arbPermAddress) {
+                governanceScore -= 30;
+                findings.push({
+                    criterion: "governance_risk",
+                    severity: "critical",
+                    message: `Arbitration ${arbObj.objectAddress.slice(0, 8)} and Service share the SAME ` +
+                        `Permission object (${svcPermAddress.slice(0, 8)}). This breaks dispute ` +
+                        `fairness — the merchant fully controls arbitration operations. ` +
+                        `Use a separate Permission object for Arbitration to ensure independent ` +
+                        `dispute resolution. (per arbitration.move: the permission field controls ` +
+                        `who can vote, confirm, and execute arbitration rulings)`,
+                    deduction: -30,
+                });
+                continue;
+            }
+            const arbPermData = permDataMap.get(arbPermAddress);
+            if (svcPermData && arbPermData) {
+                const svcOwner = svcPermData.owner?.toLowerCase();
+                const arbOwner = arbPermData.owner?.toLowerCase();
+                const svcAdmins = new Set((svcPermData.admin ?? []).map(a => a.toLowerCase()));
+                const arbAdmins = new Set((arbPermData.admin ?? []).map(a => a.toLowerCase()));
+                const ownerOverlap = svcOwner && arbOwner && svcOwner === arbOwner;
+                const adminOverlap = [...svcAdmins].some(a => arbAdmins.has(a));
+                if (ownerOverlap || adminOverlap) {
+                    const overlapType = ownerOverlap && adminOverlap
+                        ? "owner AND admin overlap"
+                        : ownerOverlap ? "same owner" : "admin overlap";
+                    governanceScore -= 20;
+                    findings.push({
+                        criterion: "governance_risk",
+                        severity: "warning",
+                        message: `Arbitration ${arbObj.objectAddress.slice(0, 8)} and Service have ` +
+                            `overlapping Permission control (${overlapType}). Even with separate ` +
+                            `Permission objects, shared control undermines dispute independence. ` +
+                            `For mainnet deployment, use a completely independent third-party ` +
+                            `Permission (different owner and admin list) for Arbitration. ` +
+                            `(testnet may tolerate this, but mainnet users should treat this as ` +
+                            `a critical trust factor)`,
+                        deduction: -20,
+                    });
+                }
+                else {
+                    strengths.push(`Arbitration ${arbObj.objectAddress.slice(0, 8)} has independent ` +
+                        `Permission (separate owner/admin) — trustworthy dispute resolution`);
+                }
+            }
+        }
+    }
     governanceScore = clampScore(governanceScore);
     let coherenceScore = 100;
     const objectAddresses = new Set();
@@ -661,7 +924,13 @@ function evaluateRisk(input) {
             deduction,
         });
     }
-    const cycles = detectCircularRefs(edges);
+    const objectTypeMap = new Map();
+    for (const o of objects) {
+        if (o.objectAddress) {
+            objectTypeMap.set(o.objectAddress, shortTypeName(o.objectType));
+        }
+    }
+    const cycles = detectCircularRefs(edges, objectTypeMap);
     if (cycles.length > 0) {
         coherenceScore -= 15;
         findings.push({
@@ -964,7 +1233,12 @@ function evaluateCompleteness(input) {
         ? parseCacheData(objectCache.get(svcObjForRequiredItems.objectAddress))
         : null;
     const compensationBalanceForItems = getBalanceValue(svcDataForRequiredItems, "compensation_fund");
-    const requiredItems = resolveRequiredItems(project.industry ?? undefined, compensationBalanceForItems);
+    const allocationsForItems = byType.get("Allocation") ?? [];
+    const orderAllocatorsBindingForItems = svcObjForRequiredItems
+        ? bindingIndex.get(`${svcObjForRequiredItems.objectAddress}#order_allocators`)?.size ?? 0
+        : 0;
+    const hasAllocationEscrowForItems = allocationsForItems.length > 0 && orderAllocatorsBindingForItems > 0;
+    const requiredItems = resolveRequiredItems(project.industry ?? undefined, compensationBalanceForItems, hasAllocationEscrowForItems);
     const requiredCount = requiredItems.filter(r => r.required).length;
     const optionalItems = requiredItems.filter(r => !r.required);
     let requiredMet = 0;
@@ -1077,7 +1351,7 @@ function evaluateCompleteness(input) {
         for (const m of machines) {
             const data = parseCacheData(objectCache.get(m.objectAddress));
             if (data) {
-                const nodeCount = getNumberField(data, "node_count") || countArrayField(data, "nodes");
+                const nodeCount = getMachineNodeCount(data);
                 if (nodeCount > 0) {
                     strengths.push(`Machine has ${nodeCount} node(s)`);
                 }
@@ -1227,16 +1501,42 @@ function evaluateCompleteness(input) {
         evaluatedAt: Date.now(),
     };
 }
-function evaluateWorthBuyingStub(_input, llmPrompt) {
+function evaluateWorthBuyingStub(input, llmPrompt) {
+    const riskResult = evaluateRisk(input);
+    const trustResult = evaluateTrust(input);
+    const completenessResult = evaluateCompleteness(input);
+    const summaryLines = [
+        "=== RULE-BASED EVALUATION SUMMARY (F-08 enriched context) ===",
+        "",
+        `Risk: ${riskResult.score}/100 — ${riskResult.summary}`,
+        ...riskResult.findings.slice(0, 3).map(f => `  - [${f.severity}] ${f.message}`),
+        "",
+        `Trust: ${trustResult.score}/100 — ${trustResult.summary}`,
+        ...trustResult.findings.slice(0, 3).map(f => `  - [${f.severity}] ${f.message}`),
+        "",
+        `Completeness: ${completenessResult.score}/100 — ${completenessResult.summary}`,
+        ...completenessResult.findings.slice(0, 3).map(f => `  - [${f.severity}] ${f.message}`),
+        "",
+        "=== END RULE-BASED SUMMARY ===",
+        "",
+    ];
+    const enrichment = summaryLines.join("\n");
+    const enrichedPrompt = llmPrompt
+        ? `${llmPrompt}\n\n${enrichment}`
+        : `${enrichment}\nInstruction: Based on the rule-based summary above, ` +
+            "evaluate whether this project is worth buying. Return a 0-100 score " +
+            "and a brief rationale. Focus on buyer risk vs. value proposition.";
     return {
         evaluationType: "worth_buying",
         score: 0,
-        summary: "Requires LLM evaluation — semantic prompt assembled. Call save_evaluation with the LLM result.",
+        summary: "Requires LLM evaluation — semantic prompt assembled with rule-based " +
+            "context (risk/trust/completeness summary). Call save_evaluation with " +
+            "the LLM result.",
         criterionScores: [],
         findings: [],
         strengths: [],
         needsLlm: true,
-        llmPrompt,
+        llmPrompt: enrichedPrompt,
         evaluatedAt: Date.now(),
     };
 }

package/dist/project/graph-builder.js

@@ -9,7 +9,12 @@ function shortTypeName(objectType) {
 }
 function extractAddressFields(obj) {
     const refs = [];
-    const objType = obj.type;
+    const rawType = obj.type;
+    let objType = rawType;
+    if (rawType && rawType.includes("::")) {
+        const parts = rawType.split("::");
+        objType = parts[parts.length - 1];
+    }
     const isAddress = (v) => typeof v === "string" && v.startsWith("0x") && v.length >= 10;
     const addRef = (addr, field, refType) => {
         if (isAddress(addr) && addr !== "0x0" && addr !== obj.object) {

package/dist/project/handlers.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import { type ProjectObject, type EvaluationType } from "@wowok/wowok";
+import { type ProjectObject, type ObjectRole, type EvaluationType } from "@wowok/wowok";
 import type { ProjectOperationInputSchema } from "../schema/project/index.js";
 type ProjectInput = z.infer<typeof ProjectOperationInputSchema>;
 export declare function handleListProjects(v: ProjectInput): Promise<{
@@ -100,14 +100,31 @@ export declare function handleUpdateProject(v: ProjectInput): Promise<{
 export declare function handleGetProjectDetail(v: ProjectInput): Promise<{
     action: "get_project_detail";
     project: import("@wowok/wowok").Project;
-    objects: ProjectObject[];
+    objects: {
+        isDraft: boolean;
+        id: string;
+        projectId: string;
+        objectAddress: string;
+        objectType: string | null;
+        objectName: string | null;
+        role: ObjectRole;
+        tags: string[] | null;
+        addedAt: number;
+        metadata: Record<string, unknown> | null;
+    }[];
+    objectCount: number;
+    onchainCount: number;
+    draftCount: number;
     objectGroups: {
         core: ProjectObject[];
         dependency: ProjectObject[];
         reference: ProjectObject[];
         other: ProjectObject[];
+        draft: ProjectObject[];
         stats: {
             total: number;
+            onchain_count: number;
+            draft_count: number;
             core_count: number;
             dependency_count: number;
             reference_count: number;
@@ -212,6 +229,8 @@ export declare function handleEvaluateProject(v: ProjectInput): Promise<{
     needsLlm: boolean;
     llmPrompt: string | undefined;
     evaluationId: string;
+    refreshWarning: string | undefined;
+    graphFallbackWarning: string | undefined;
 }>;
 export declare function handleSaveEvaluation(v: ProjectInput): Promise<{
     action: "save_evaluation";
@@ -248,6 +267,67 @@ export declare function handleCloneProjectToNetwork(v: ProjectInput): Promise<{
     message: string;
     next_steps: string;
 }>;
+export declare function handleMigrateToMainnet(v: ProjectInput): Promise<{
+    action: "migrate_to_mainnet";
+    migration_status: string;
+    source_project: {
+        prefix: string;
+        network: string;
+        preserved: boolean;
+    };
+    target_project: {
+        prefix: string;
+        project_id: string;
+        network: string;
+        cloned_objects_count: number;
+    };
+    key_principle: string;
+    migration_plan: ({
+        step: number;
+        status: string;
+        action: string;
+        description: string;
+        result: string;
+        deployment_plan?: undefined;
+        critical_note?: undefined;
+        names_to_register?: undefined;
+    } | {
+        step: number;
+        status: string;
+        action: string;
+        description: string;
+        deployment_plan: {
+            order: number;
+            object_type: string;
+            object_name: string;
+            operation_type: string;
+            localmark_name: string;
+            note: string;
+        }[];
+        critical_note: string;
+        result?: undefined;
+        names_to_register?: undefined;
+    } | {
+        step: number;
+        status: string;
+        action: string;
+        description: string;
+        names_to_register: string[];
+        result?: undefined;
+        deployment_plan?: undefined;
+        critical_note?: undefined;
+    } | {
+        step: number;
+        status: string;
+        action: string;
+        description: string;
+        result?: undefined;
+        deployment_plan?: undefined;
+        critical_note?: undefined;
+        names_to_register?: undefined;
+    })[];
+    summary: string;
+}>;
 export declare function handleGetObjectDiff(v: ProjectInput): Promise<{
     action: "get_object_diff";
     address: string;
@@ -284,6 +364,23 @@ export declare function handleGetMachineGraph(v: ProjectInput): Promise<{
     }[];
     published: boolean | null;
     paused: boolean | null;
+    mermaid: string;
+    tree_outline: string;
+    ascii_art: string;
+    markmap: string;
+}>;
+export declare function handleGetGuardGraph(v: ProjectInput): Promise<{
+    action: "get_guard_graph";
+    guardAddress: string;
+    guardName: string | null;
+    root: any;
+    table: any[];
+    rely: any;
+    immutable: any;
+    mermaid: string;
+    tree_outline: string;
+    ascii_art: string;
+    markmap: string;
 }>;
 export declare function handlePreEvaluateCheck(v: ProjectInput): Promise<{
     action: "pre_evaluate_check";