@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/project/handlers.js

@@ -1,8 +1,13 @@
-import { LocalProject, LocalMark, query_objects, query_table, } from "@wowok/wowok";
+import { LocalProject, LocalMark, query_objects, } from "@wowok/wowok";
+import { fetchMachineNodes } from "./machine-nodes.js";
 import { GraphBuilder } from "./graph-builder.js";
 import { SemanticAssembler } from "./semantic-assembler.js";
 import { runEvaluation, compareProjects, } from "./evaluation.js";
 import { TaskTracker } from "./task-tracker.js";
+import { renderGuardMermaid, renderGuardTreeIndented, renderGuardAscii, renderGuardMarkmap, } from "../knowledge/guard-render.js";
+import { renderMachineMermaid, renderMachineTreeIndented, renderMachineAscii, renderMachineMarkmap, } from "../knowledge/machine-render.js";
+import { inferTraitsFromDescription, findSimilarIndustries, } from "../knowledge/industry-generalizer.js";
+import { isObjectOfType } from "../schema/utils/object-type-utils.js";
 const localProject = LocalProject.Instance();
 function requireField(value, name) {
     if (value === undefined || value === null) {
@@ -41,6 +46,17 @@ async function resolveObjectAddress(v) {
     }
     throw new Error("Either 'object_address' or 'object_name_add' is required for add_object");
 }
+function isDraftObject(obj) {
+    if (obj.objectAddress && obj.objectAddress.startsWith("draft:"))
+        return true;
+    const meta = obj.metadata;
+    return !!(meta && meta.status === "draft");
+}
+function isOnchainObject(obj) {
+    if (isDraftObject(obj))
+        return false;
+    return !!obj.objectAddress && obj.objectAddress.startsWith("0x");
+}
 export async function handleListProjects(v) {
     const filter = {};
     if (v.filter_status)
@@ -60,12 +76,13 @@ export async function handleListProjects(v) {
             if (o.objectType)
                 types.add(o.objectType);
         }
+        const onchainCount = objs.filter(o => isOnchainObject(o)).length;
         if (p.status === "draft" && objs.length > 0) {
             const updated = await localProject.updateProject(p.id, { status: "active" });
             if (updated) {
                 return {
                     ...updated,
-                    objectCount: objs.length,
+                    objectCount: onchainCount,
                     evaluationCount: evals.length,
                     objectTypes: Array.from(types),
                 };
@@ -73,7 +90,7 @@ export async function handleListProjects(v) {
         }
         return {
             ...p,
-            objectCount: objs.length,
+            objectCount: onchainCount,
             evaluationCount: evals.length,
             objectTypes: Array.from(types),
         };
@@ -85,12 +102,30 @@ export async function handleListProjects(v) {
     };
 }
 export async function handleCreateProject(v) {
-    const prefix = requireField(v.project, "project (prefix)");
     const name = requireField(v.project_name, "project_name");
+    let prefix = v.project;
+    if (!prefix) {
+        prefix = name
+            .toLowerCase()
+            .trim()
+            .replace(/[^a-z0-9]+/g, "_")
+            .replace(/^_+|_+$/g, "")
+            .substring(0, 60);
+        if (!prefix) {
+            prefix = `proj_${Date.now().toString(36)}`;
+        }
+    }
     const existing = await localProject.getProjectByPrefix(prefix);
     if (existing) {
-        throw new Error(`Project prefix '${prefix}' already exists (project: '${existing.name}', id: '${existing.id}'). ` +
-            `Use a different prefix or update the existing project.`);
+        if (v.project) {
+            throw new Error(`Project prefix '${prefix}' already exists (project: '${existing.name}', id: '${existing.id}'). ` +
+                `Use a different prefix or update the existing project.`);
+        }
+        let suffix = 2;
+        while (await localProject.getProjectByPrefix(`${prefix}_${suffix}`)) {
+            suffix++;
+        }
+        prefix = `${prefix}_${suffix}`;
     }
     const create = {
         prefix,
@@ -103,6 +138,26 @@ export async function handleCreateProject(v) {
         network: v.project_network ?? "testnet",
     };
     const project = await localProject.createProject(create);
+    if (v.service_address) {
+        try {
+            await localProject.addObject(project.id, {
+                objectAddress: v.service_address,
+                objectType: "Service",
+                objectName: v.service_address.startsWith("0x")
+                    ? undefined
+                    : v.service_address,
+                role: "core",
+                metadata: {
+                    auto_added_from_service_address: true,
+                    added_at: new Date().toISOString(),
+                },
+            });
+        }
+        catch (err) {
+            console.warn(`[create_project] Failed to auto-add Service '${v.service_address}': ${err.message}. ` +
+                `Use add_object action to manually add it.`);
+        }
+    }
     const industry = v.project_industry;
     const skipTemplates = v.skip_templates === true;
     if (industry && industry !== "general" && !skipTemplates) {
@@ -116,7 +171,28 @@ export async function handleCreateProject(v) {
                 business_intent: v.project_description ?? name,
                 industry,
             };
-            const blueprint = registry.applyTemplate(industry, context.business_intent, context);
+            const blueprint = await registry.applyTemplate(industry, context.business_intent, context);
+            const intentInference = inferTraitsFromDescription(context.business_intent);
+            const industryMatches = findSimilarIndustries(intentInference.traits, 3);
+            const intentInferenceSummary = {
+                traits: intentInference.traits,
+                confidence: intentInference.confidence,
+                matched_keywords: intentInference.matched_keywords,
+                top_matches: industryMatches.map((m) => ({
+                    industry: m.industry,
+                    similarity: m.similarity,
+                })),
+            };
+            const topMatch = industryMatches[0];
+            const industryMismatchHint = topMatch &&
+                !industryMatches.some((m) => m.industry === industry) &&
+                intentInference.confidence >= 0.3 &&
+                topMatch.similarity >= 0.6
+                ? `Intent inference suggests industry '${topMatch.industry}' ` +
+                    `(similarity ${(topMatch.similarity * 100).toFixed(0)}%) may fit the description ` +
+                    `better than the chosen '${industry}'. Call action='recommend_industry' for the full ` +
+                    `recommendation chain, or ignore this hint if '${industry}' was chosen intentionally.`
+                : undefined;
             const draftObjects = [];
             for (const obj of blueprint.objects) {
                 const projectObj = await localProject.addObject(project.id, {
@@ -150,6 +226,20 @@ export async function handleCreateProject(v) {
                 },
             }));
             await localProject.saveGraphEdges(project.id, graphEdges);
+            try {
+                await localProject.saveDocument(project.id, context.network, JSON.stringify({
+                    applied_template: blueprint.applied_template,
+                    industry_source: blueprint.industry_source,
+                    steps: blueprint.steps,
+                    scenarios: blueprint.scenarios ?? [],
+                    validation: blueprint.validation,
+                    intent_inference: intentInferenceSummary,
+                    generated_at: new Date().toISOString(),
+                }, null, 2), "blueprint");
+            }
+            catch (docErr) {
+                console.warn(`[create_project] Failed to persist blueprint document: ${docErr.message}`);
+            }
             return {
                 action: "create_project",
                 project,
@@ -161,6 +251,8 @@ export async function handleCreateProject(v) {
                     steps_count: blueprint.steps.length,
                     scenarios_count: blueprint.scenarios?.length ?? 0,
                     key_risk: registry.getMode(industry)?.key_risk,
+                    intent_inference: intentInferenceSummary,
+                    ...(industryMismatchHint ? { industry_mismatch_hint: industryMismatchHint } : {}),
                 },
                 recommended_creation_order: getRecommendedCreationOrder(industry),
             };
@@ -183,6 +275,29 @@ export async function handleCreateProject(v) {
             recommended_creation_order: getRecommendedCreationOrder(industry),
         };
     }
+    if (!industry) {
+        const intentText = (v.project_description ?? name).trim();
+        if (intentText) {
+            try {
+                const { handleRecommendIndustry } = await import("./mode-actions.js");
+                const rec = handleRecommendIndustry({ intent: intentText });
+                if (rec.recommendations.length > 0) {
+                    return {
+                        action: "create_project",
+                        project,
+                        recommended_creation_order: getRecommendedCreationOrder(industry),
+                        recommended_industries: rec.recommendations,
+                        hint: "No industry specified. Based on your description, top match is '" +
+                            rec.recommendations[0].industry + "'. To get a ready-made blueprint " +
+                            "(~10 draft objects + graph edges), recreate with project_industry set — " +
+                            "or continue from scratch with add_object.",
+                    };
+                }
+            }
+            catch {
+            }
+        }
+    }
     return {
         action: "create_project",
         project,
@@ -264,7 +379,11 @@ export async function handleCreateProjectFromOnchain(v) {
         throw new Error(`Service object not found on ${network}: the address ${serviceAddress} does not exist on this network. ` +
             `Switch to the ${otherNetwork} network and try again.`);
     }
-    if (!rootType.includes("::service::Service")) {
+    const normalizedType = rootType.toLowerCase();
+    const isService = normalizedType.includes("::service::service") ||
+        normalizedType === "service" ||
+        normalizedType.endsWith("::service");
+    if (!isService) {
         throw new Error(`Object ${serviceAddress} is not a Service (its on-chain type is "${rootType}"). ` +
             `Only on-chain Service objects can be imported as a project root.`);
     }
@@ -406,6 +525,8 @@ export async function handleGetProjectDetail(v) {
         }
     }
     const VALID_ROLES = new Set(["core", "dependency", "reference"]);
+    const draftObjs = objects.filter(o => isDraftObject(o));
+    const onchainObjs = objects.filter(o => isOnchainObject(o));
     const core = objects.filter(o => o.role === "core");
     const dependency = objects.filter(o => o.role === "dependency");
     const reference = objects.filter(o => o.role === "reference");
@@ -421,8 +542,11 @@ export async function handleGetProjectDetail(v) {
         dependency,
         reference,
         other,
+        draft: draftObjs,
         stats: {
             total: objects.length,
+            onchain_count: onchainObjs.length,
+            draft_count: draftObjs.length,
             core_count: core.length,
             dependency_count: dependency.length,
             reference_count: reference.length,
@@ -435,10 +559,17 @@ export async function handleGetProjectDetail(v) {
             }, {}),
         },
     };
+    const objectsWithDraftFlag = objects.map(o => ({
+        ...o,
+        isDraft: isDraftObject(o),
+    }));
     return {
         action: "get_project_detail",
         project: effectiveProject,
-        objects,
+        objects: objectsWithDraftFlag,
+        objectCount: objects.length,
+        onchainCount: onchainObjs.length,
+        draftCount: draftObjs.length,
         objectGroups,
         graphEdgeCount: edges.length,
         serviceStatus,
@@ -593,7 +724,8 @@ async function buildGraphSync(projectId, project, v) {
         if (objects.length === 0) {
             throw new Error("Cannot build graph: project has no objects and no service_address");
         }
-        const coreObj = objects.find(o => o.role === "core");
+        const coreObj = objects.find(o => o.role === "core")
+            ?? objects.find(o => o.objectType?.includes("service::Service") || o.objectType === "Service");
         rootAddress = (coreObj ?? objects[0]).objectAddress;
     }
     const builder = new GraphBuilder({
@@ -689,6 +821,40 @@ async function verifyServiceBindings(serviceAddress, network) {
         return null;
     }
 }
+function synthesizeOnchainFallbackEdges(serviceAddress, bindings) {
+    const edges = [];
+    const now = Date.now();
+    const fieldMap = [
+        { key: "Service.machine", fieldName: "machine", relationshipType: "machine" },
+        { key: "Service.permission", fieldName: "permission", relationshipType: "permission" },
+        { key: "Service.buy_guard", fieldName: "buy_guard", relationshipType: "guard" },
+        { key: "Service.um", fieldName: "um", relationshipType: "um" },
+        { key: "Service.order_allocators", fieldName: "order_allocators", relationshipType: "guard" },
+        { key: "Service.arbitrations", fieldName: "arbitrations", relationshipType: "arbitration" },
+    ];
+    for (const fm of fieldMap) {
+        const b = bindings.bindings[fm.key];
+        if (!b || !b.verified)
+            continue;
+        const target = b.actual ?? `${serviceAddress}#${fm.fieldName}#synthetic`;
+        edges.push({
+            id: `onchain-fallback-${fm.fieldName}-${now}`,
+            projectId: null,
+            sourceObject: serviceAddress,
+            targetObject: target,
+            edgeSource: "internal",
+            relationshipType: fm.relationshipType,
+            fieldName: fm.fieldName,
+            depth: 1,
+            verified: true,
+            weight: 1,
+            direction: "outbound",
+            metadata: { onchain_fallback: true },
+            cachedAt: now,
+        });
+    }
+    return edges;
+}
 function shortLabel(addrOrName) {
     if (!addrOrName)
         return "(empty)";
@@ -721,11 +887,26 @@ export async function handleEvaluateProject(v) {
     const project = await localProject.getProject(projectId);
     if (!project)
         throw new Error(`Project not found: ${projectId}`);
-    if (v.refresh_before_eval) {
-        await refreshProjectObjects(projectId, project.network);
+    let refreshWarning;
+    if (v.refresh_before_eval !== false) {
+        const refreshResult = await refreshProjectObjects(projectId, project.network);
+        if (refreshResult.failedCount > 0) {
+            refreshWarning = `Refresh completed with ${refreshResult.failedCount} failed object(s) ` +
+                `out of ${refreshResult.refreshedCount + refreshResult.failedCount} total. ` +
+                `Evaluation may use stale data for failed objects.`;
+        }
     }
     const objects = await localProject.listObjects(projectId);
-    const edges = await localProject.getGraph(projectId);
+    let edges = await localProject.getGraph(projectId);
+    let graphFallbackWarning;
+    if (edges.length === 0 && project.serviceAddress) {
+        const bindings = await verifyServiceBindings(project.serviceAddress, project.network);
+        if (bindings && Object.values(bindings.bindings).some(b => b.verified)) {
+            edges = synthesizeOnchainFallbackEdges(project.serviceAddress, bindings);
+            const verifiedCount = Object.values(bindings.bindings).filter(b => b.verified).length;
+            graphFallbackWarning = `Graph is empty; fell back to on-chain direct query (${verifiedCount}/${Object.keys(bindings.bindings).length} Service bindings verified). Call build_graph to construct the full relationship graph.`;
+        }
+    }
     const addresses = objects.map(o => o.objectAddress);
     const cacheEntries = await localProject.getCachedObjects(addresses);
     const objectCache = new Map();
@@ -778,6 +959,8 @@ export async function handleEvaluateProject(v) {
         needsLlm: result.needsLlm,
         llmPrompt: result.llmPrompt,
         evaluationId,
+        refreshWarning,
+        graphFallbackWarning,
     };
 }
 export async function handleSaveEvaluation(v) {
@@ -930,6 +1113,123 @@ export async function handleCloneProjectToNetwork(v) {
         next_steps: `Execute the same onchain_operations sequence with env.network='${targetNetwork}' to deploy objects. Then call update_project to set service_address, and build_graph to construct the new project's relationship graph.`,
     };
 }
+export async function handleMigrateToMainnet(v) {
+    const sourceProjectId = await resolveProjectId(v);
+    const sourceProject = await localProject.getProject(sourceProjectId);
+    if (!sourceProject) {
+        throw new Error(`Source project not found: ${sourceProjectId}`);
+    }
+    if (sourceProject.network === "mainnet") {
+        throw new Error(`Source project '${sourceProject.prefix}' is already on mainnet. ` +
+            `migrate_to_mainnet is for testnet→mainnet migration only. ` +
+            `To clone to testnet, use clone_project_to_network with target_network='testnet'.`);
+    }
+    const cloneInput = { ...v, target_network: "mainnet" };
+    const cloneResult = await handleCloneProjectToNetwork(cloneInput);
+    const sourceObjects = await localProject.listObjects(sourceProjectId);
+    const deploymentPlan = sourceObjects
+        .filter(obj => obj.objectType !== null)
+        .map((obj, idx) => ({
+        order: idx + 1,
+        object_type: obj.objectType,
+        object_name: obj.objectName ?? "<unnamed>",
+        operation_type: mapObjectTypeToOperationType(obj.objectType),
+        localmark_name: obj.objectName ?? `<unnamed_${idx + 1}>`,
+        note: `Deploy on mainnet with env.network='mainnet'. Use the SAME LocalMark name '${obj.objectName ?? "<unnamed>"}' — it will resolve to a DIFFERENT mainnet address. The testnet address is NOT reused.`,
+    }));
+    return {
+        action: "migrate_to_mainnet",
+        migration_status: "step_1_complete_steps_2_5_pending_user_action",
+        source_project: {
+            prefix: sourceProject.prefix,
+            network: sourceProject.network,
+            preserved: true,
+        },
+        target_project: {
+            prefix: cloneResult.new_prefix,
+            project_id: cloneResult.new_project_id,
+            network: "mainnet",
+            cloned_objects_count: cloneResult.cloned_objects_count,
+        },
+        key_principle: "testnet and mainnet are DIFFERENT projects. Same LocalMark names may exist in both networks, " +
+            "but they correspond to DIFFERENT on-chain addresses. The testnet project is preserved unchanged. " +
+            "LocalMark names are NETWORK-SCOPED: a name resolves to a testnet address when env.network=testnet, " +
+            "and to a mainnet address when env.network=mainnet. Register the SAME name TWICE (once per network).",
+        migration_plan: [
+            {
+                step: 1,
+                status: "completed",
+                action: "clone_project_to_network",
+                description: "Clone source project metadata to mainnet project",
+                result: `Created mainnet project '${cloneResult.new_prefix}' with ${cloneResult.cloned_objects_count} draft object(s).`,
+            },
+            {
+                step: 2,
+                status: "pending_user_action",
+                action: "onchain_operations",
+                description: "Re-deploy all objects on mainnet. Set env.network='mainnet' and env.project='" +
+                    cloneResult.new_prefix + "'. Use the SAME LocalMark names — they will resolve to " +
+                    "DIFFERENT mainnet addresses. Mainnet accounts need real (non-test) SUI for gas.",
+                deployment_plan: deploymentPlan,
+                critical_note: "Re-deploy in dependency order: Permission → Machine → Contact → Guard(s) → Service. " +
+                    "For the Service↔Guard circular dependency, use the 3-step pattern " +
+                    "(Service without order_allocators → Guards → Service with order_allocators + publish).",
+            },
+            {
+                step: 3,
+                status: "pending_user_action",
+                action: "local_mark_operation",
+                description: "Re-register LocalMark names on mainnet. Each name from step 2 must be registered " +
+                    "with its NEW mainnet address. The testnet LocalMark entries are NOT migrated " +
+                    "automatically — mainnet has its own name registry.",
+                names_to_register: sourceObjects
+                    .filter(obj => obj.objectName !== null)
+                    .map(obj => obj.objectName),
+            },
+            {
+                step: 4,
+                status: "pending_user_action",
+                action: "update_project",
+                description: "Set service_address on the mainnet project to the mainnet Service address " +
+                    "(from step 2). Use project='" + cloneResult.new_prefix + "' and the mainnet " +
+                    "Service LocalMark name or 0x address.",
+            },
+            {
+                step: 5,
+                status: "pending_user_action",
+                action: "build_graph",
+                description: "Rebuild the relationship graph on the mainnet project. Use project='" +
+                    cloneResult.new_prefix + "'. This constructs edges from the newly-deployed " +
+                    "mainnet object bindings (machine, order_allocators, guards, etc.).",
+            },
+        ],
+        summary: "Migration step 1 (clone) complete. Steps 2-5 require user action: deploy objects on mainnet, " +
+            "re-register LocalMark names, set service_address, and rebuild the graph. The testnet project " +
+            "is preserved unchanged — you can run both in parallel until ready to deprecate the testnet version.",
+    };
+}
+function mapObjectTypeToOperationType(objectType) {
+    const map = {
+        service: "service",
+        machine: "machine",
+        guard: "guard",
+        permission: "permission",
+        progress: "progress",
+        arb: "arbitration",
+        arbitration: "arbitration",
+        contact: "contact",
+        treasury: "treasury",
+        reward: "reward",
+        allocation: "allocation",
+        repository: "repository",
+        demand: "demand",
+        order: "order",
+        personal: "personal",
+        payment: "payment",
+        proof: "proof",
+    };
+    return map[objectType.toLowerCase()] ?? objectType.toLowerCase();
+}
 export async function handleGetObjectDiff(v) {
     const address = requireField(v.diff_address, "diff_address");
     const fromTime = requireField(v.diff_from_time, "diff_from_time");
@@ -1009,39 +1309,7 @@ export async function handleGetMachineGraph(v) {
     const edgeList = [];
     let rawNodes = [];
     try {
-        const allFieldObjectIds = [];
-        let cursor = undefined;
-        for (;;) {
-            const tableResult = await query_table({
-                parent: machineAddress,
-                cursor: cursor ?? undefined,
-                network,
-            });
-            if (!tableResult?.items || tableResult.items.length === 0)
-                break;
-            for (const item of tableResult.items) {
-                if (item.object)
-                    allFieldObjectIds.push(item.object);
-            }
-            if (!tableResult.hasNextPage || !tableResult.nextCursor)
-                break;
-            cursor = tableResult.nextCursor;
-        }
-        if (allFieldObjectIds.length > 0) {
-            const BATCH = 50;
-            for (let i = 0; i < allFieldObjectIds.length; i += BATCH) {
-                const batch = allFieldObjectIds.slice(i, i + BATCH);
-                const nodeQueryResult = await query_objects({
-                    objects: batch,
-                    network,
-                });
-                for (const obj of nodeQueryResult?.objects ?? []) {
-                    if (obj.type === "TableItem_MachineNode") {
-                        rawNodes.push(obj);
-                    }
-                }
-            }
-        }
+        rawNodes = await fetchMachineNodes(machineAddress, network);
     }
     catch (e) {
         throw new Error(`Failed to query Machine nodes on ${network}: ${e instanceof Error ? e.message : String(e)}`);
@@ -1082,6 +1350,106 @@ export async function handleGetMachineGraph(v) {
         edges: edgeList,
         published,
         paused,
+        mermaid: renderMachineMermaid(Array.from(nodeMap.values()), edgeList),
+        tree_outline: renderMachineTreeIndented({
+            nodes: Array.from(nodeMap.values()),
+            edges: edgeList,
+            machineName,
+            machineAddress,
+            published,
+            paused,
+        }),
+        ascii_art: renderMachineAscii({
+            nodes: Array.from(nodeMap.values()),
+            edges: edgeList,
+            machineName,
+            machineAddress,
+            published,
+            paused,
+        }),
+        markmap: renderMachineMarkmap({
+            nodes: Array.from(nodeMap.values()),
+            edges: edgeList,
+            machineName,
+            machineAddress,
+            published,
+            paused,
+        }),
+    };
+}
+export async function handleGetGuardGraph(v) {
+    const projectId = await resolveProjectId(v);
+    const guardAddress = await resolveObjectAddress(v);
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found (id: ${projectId})`);
+    const objects = await localProject.listObjects(projectId);
+    const guardObj = objects.find(o => o.objectAddress === guardAddress);
+    if (!guardObj) {
+        throw new Error(`Object ${guardAddress} is not part of project '${project.prefix}'. ` +
+            `Add it via add_object first.`);
+    }
+    const network = (project.network ?? "testnet");
+    let guardData = null;
+    try {
+        const queryResult = await query_objects({
+            objects: [guardAddress],
+            network,
+        });
+        guardData = queryResult?.objects?.[0] ?? null;
+    }
+    catch (e) {
+        throw new Error(`Failed to query Guard on ${network}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!guardData) {
+        throw new Error(`Guard ${guardAddress} not found on ${network}. ` +
+            `It may not exist on this network — try switching networks.`);
+    }
+    let guardName = null;
+    try {
+        const mark = await LocalMark.Instance().get(guardAddress);
+        guardName = mark?.name ?? null;
+    }
+    catch {
+    }
+    const root = guardData.root ?? guardData.data?.root ?? null;
+    const table = guardData.table ?? guardData.data?.table ?? [];
+    const rely = guardData.rely ?? guardData.data?.rely ?? null;
+    const immutable = guardData.immutable ?? guardData.data?.immutable ?? null;
+    if (!root) {
+        throw new Error(`Guard ${guardAddress} has no root node. The Guard may be empty or corrupted. ` +
+            `Use query_toolkit to inspect the raw object data.`);
+    }
+    const mermaidStr = renderGuardMermaid(root);
+    const tableForRender = Array.isArray(table) ? table.map((t) => ({
+        identifier: t.identifier,
+        name: t.name,
+        value_type: t.value_type,
+        b_submission: t.b_submission,
+        value: t.value,
+    })) : [];
+    const guardRenderInput = {
+        root: root,
+        table: tableForRender,
+        guardName,
+        guardAddress,
+        rely: rely ?? null,
+    };
+    const treeOutline = renderGuardTreeIndented(guardRenderInput);
+    const asciiArt = renderGuardAscii(guardRenderInput);
+    const markmap = renderGuardMarkmap(guardRenderInput);
+    return {
+        action: "get_guard_graph",
+        guardAddress,
+        guardName,
+        root,
+        table: Array.isArray(table) ? table : [],
+        rely: rely ?? null,
+        immutable: immutable ?? null,
+        mermaid: mermaidStr,
+        tree_outline: treeOutline,
+        ascii_art: asciiArt,
+        markmap: markmap,
     };
 }
 export async function handlePreEvaluateCheck(v) {
@@ -1164,7 +1532,7 @@ export async function handlePreEvaluateCheck(v) {
         });
     }
     if (project.perspective === "producer") {
-        const hasService = objects.some(o => o.objectType === "service");
+        const hasService = objects.some(o => isObjectOfType(o.objectType, "service"));
         if (!hasService) {
             missing.push({
                 id: "PE-06",
@@ -1271,8 +1639,12 @@ export async function handleVerifyDeployment(v) {
     const chainObjects = chainResult?.objects ?? [];
     const chainByAddress = new Map();
     for (const co of chainObjects) {
-        if (co && typeof co === "object" && "objectId" in co) {
-            chainByAddress.set(co.objectId, co);
+        if (co && typeof co === "object") {
+            const coRecord = co;
+            const addr = coRecord.object ?? coRecord.objectId ?? coRecord.object_id;
+            if (typeof addr === "string") {
+                chainByAddress.set(addr, co);
+            }
         }
     }
     const results = [];
@@ -1294,7 +1666,7 @@ export async function handleVerifyDeployment(v) {
         const sqliteFields = sqliteData?.data ?? {};
         const differences = [];
         let bindings;
-        if (obj.objectType === "service") {
+        if (isObjectOfType(obj.objectType, "service")) {
             const fieldsToCompare = ["machine", "permission", "buy_guard", "arbitrations", "rewards", "repositories"];
             for (const f of fieldsToCompare) {
                 const sqliteVal = sqliteFields[f];
@@ -1319,7 +1691,7 @@ export async function handleVerifyDeployment(v) {
                 });
             }
         }
-        else if (obj.objectType === "machine") {
+        else if (isObjectOfType(obj.objectType, "machine")) {
             if (sqliteFields.bPublished !== undefined && chainData.bPublished !== undefined
                 && sqliteFields.bPublished !== chainData.bPublished) {
                 differences.push({