@wowok/agent-mcp 2.6.0 → 2.6.3

package/dist/project/handlers.js

@@ -1,7 +1,11 @@
-import { LocalProject, LocalMark, query_objects, } from "@wowok/wowok";
+import { LocalProject, LocalMark, query_objects, query_table, } from "@wowok/wowok";
 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 { isObjectOfType } from "../schema/utils/object-type-utils.js";
 const localProject = LocalProject.Instance();
 function requireField(value, name) {
     if (value === undefined || value === null) {
@@ -21,8 +25,17 @@ async function resolveProjectId(v) {
     throw new Error("Either 'project_id' or 'project' (prefix) is required for this action");
 }
 async function resolveObjectAddress(v) {
-    if (v.object_address)
-        return v.object_address;
+    if (v.object_address) {
+        const addr = v.object_address;
+        const isHexAddress = /^0x[0-9a-fA-F]{32,64}$/.test(addr);
+        const isDraftSentinel = addr.startsWith("draft:");
+        if (!isHexAddress && !isDraftSentinel) {
+            throw new Error(`Invalid object_address format: '${addr.slice(0, 40)}${addr.length > 40 ? "..." : ""}'. ` +
+                `Expected a valid Sui address (0x + 32-64 hex chars) or 'draft:<name>' sentinel. ` +
+                `To reference an object by name, use 'object_name_add' instead of 'object_address'.`);
+        }
+        return addr;
+    }
     if (v.object_name_add) {
         const mark = await LocalMark.Instance().get(v.object_name_add);
         if (mark?.address)
@@ -31,6 +44,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)
@@ -50,12 +74,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),
                 };
@@ -63,7 +88,7 @@ export async function handleListProjects(v) {
         }
         return {
             ...p,
-            objectCount: objs.length,
+            objectCount: onchainCount,
             evaluationCount: evals.length,
             objectTypes: Array.from(types),
         };
@@ -75,12 +100,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,
@@ -93,7 +136,148 @@ export async function handleCreateProject(v) {
         network: v.project_network ?? "testnet",
     };
     const project = await localProject.createProject(create);
-    return { action: "create_project", project };
+    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) {
+        try {
+            const { IndustryModeRegistry } = await import("../extensions/index.js");
+            const registry = IndustryModeRegistry.Instance();
+            const context = {
+                prefix,
+                version: project.currentVersion ?? "v1",
+                network: (project.network ?? "testnet"),
+                business_intent: v.project_description ?? name,
+                industry,
+            };
+            const blueprint = registry.applyTemplate(industry, context.business_intent, context);
+            const draftObjects = [];
+            for (const obj of blueprint.objects) {
+                const projectObj = await localProject.addObject(project.id, {
+                    objectAddress: `draft:${obj.name}`,
+                    objectType: obj.object_type,
+                    objectName: obj.name,
+                    role: obj.object_type === "service" ? "core" : "dependency",
+                    metadata: {
+                        status: "draft",
+                        config: obj.config,
+                        publish_required: obj.publish_required,
+                        description: obj.description,
+                        entry_id: obj.entry_id,
+                    },
+                });
+                draftObjects.push(projectObj);
+            }
+            const graphEdges = blueprint.edges.map((e) => ({
+                projectId: project.id,
+                sourceObject: e.from,
+                targetObject: e.to,
+                edgeSource: "internal",
+                relationshipType: mapEdgeKindToRelationshipType(e.edge_kind),
+                fieldName: e.field_path,
+                depth: 0,
+                verified: false,
+                weight: 1.0,
+                metadata: {
+                    blueprint: true,
+                    required_at_publish: e.required_at_publish,
+                },
+            }));
+            await localProject.saveGraphEdges(project.id, graphEdges);
+            return {
+                action: "create_project",
+                project,
+                blueprint: {
+                    objects_count: draftObjects.length,
+                    edges_count: graphEdges.length,
+                    industry_source: blueprint.industry_source,
+                    applied_template: blueprint.applied_template,
+                    steps_count: blueprint.steps.length,
+                    scenarios_count: blueprint.scenarios?.length ?? 0,
+                    key_risk: registry.getMode(industry)?.key_risk,
+                },
+                recommended_creation_order: getRecommendedCreationOrder(industry),
+            };
+        }
+        catch (err) {
+            return {
+                action: "create_project",
+                project,
+                blueprint_warning: `Industry template application failed: ${err.message}. Project created without blueprint — use add_object to manually add objects.`,
+                recommended_creation_order: getRecommendedCreationOrder(industry),
+            };
+        }
+    }
+    if (skipTemplates) {
+        return {
+            action: "create_project",
+            project,
+            blueprint_skipped: true,
+            hint: "skip_templates=true — no industry blueprint objects were created. Use add_object to manually add objects to this project.",
+            recommended_creation_order: getRecommendedCreationOrder(industry),
+        };
+    }
+    return {
+        action: "create_project",
+        project,
+        recommended_creation_order: getRecommendedCreationOrder(industry),
+    };
+}
+function getRecommendedCreationOrder(industry) {
+    const industryNote = industry && industry !== "general"
+        ? ` (industry="${industry}" — see IndustryMode.build_notes for overrides)`
+        : "";
+    return [
+        { step: 1, object: "Permission", reason: "Base permission object, referenced by all other objects.", required: true },
+        { step: 2, object: "Treasury", reason: "Standalone object, no dependencies. Optional but recommended for fund management.", required: false },
+        { step: 3, object: "Machine", reason: `Requires Permission. publish:true locks nodes/pairs/forwards permanently.${industryNote}`, required: true },
+        { step: 4, object: "Contact", reason: "Requires Permission. Used as Service.um (user manual / contact info).", required: true },
+        { step: 5, object: "Arbitration", reason: "Requires Permission. Optional but recommended for dispute resolution.", required: false },
+        { step: 6, object: "Service (unpublished)", reason: "Requires Permission + Machine + Contact + Arbitration. Create WITHOUT publish:true first.", required: true },
+        { step: 7, object: "Guard x N", reason: "Can reference Service via LocalMark. Create all Guards (buy_guard, allocator_guard, etc.) before publishing Service.", required: true },
+        { step: 8, object: "Service update + publish", reason: "Add order_allocators referencing Guards, then publish:true. After publish, machine/order_allocators are immutable.", required: true },
+    ];
+}
+function mapEdgeKindToRelationshipType(edgeKind) {
+    switch (edgeKind) {
+        case "machine":
+        case "compensation_fund":
+        case "parent":
+            return "bind";
+        case "order_allocators":
+            return "create";
+        case "arbitrations":
+        case "rewards":
+            return "trigger";
+        case "buy_guard":
+        case "permission":
+        case "guard":
+            return "validate";
+        case "service":
+        case "progress":
+            return "consume";
+        default:
+            return "bind";
+    }
 }
 export async function handleCreateProjectFromOnchain(v) {
     const serviceAddress = requireField(v.service_address, "service_address");
@@ -112,6 +296,35 @@ export async function handleCreateProjectFromOnchain(v) {
         }
         prefix = `${prefix}_${suffix}`;
     }
+    const otherNetwork = network === "testnet" ? "mainnet" : "testnet";
+    let rootType = null;
+    try {
+        const rootQuery = await query_objects({
+            objects: [serviceAddress],
+            network,
+        });
+        const rootObj = rootQuery?.objects?.[0];
+        if (rootObj && rootObj.object) {
+            rootType = rootObj.type ?? null;
+        }
+    }
+    catch (e) {
+        throw new Error(`Failed to query ${network} for the Service object: ` +
+            `${e instanceof Error ? e.message : String(e)}. ` +
+            `Check the network connection or try the ${otherNetwork} network.`);
+    }
+    if (!rootType) {
+        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.`);
+    }
+    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.`);
+    }
     const project = await localProject.createProject({
         prefix,
         name,
@@ -123,7 +336,7 @@ export async function handleCreateProjectFromOnchain(v) {
         network: network,
     });
     const builder = new GraphBuilder({
-        maxDepth: v.max_depth ?? 3,
+        maxDepth: v.max_depth ?? v.depth ?? 3,
         enableRegistrar: v.enable_registrar ?? true,
         enablePotential: v.enable_potential ?? false,
         projectId: project.id,
@@ -229,11 +442,75 @@ export async function handleGetProjectDetail(v) {
             }
         }
     }
+    let serviceStatus = null;
+    if (effectiveProject.serviceAddress && effectiveProject.network) {
+        try {
+            const svcQuery = await query_objects({
+                objects: [effectiveProject.serviceAddress],
+                network: effectiveProject.network,
+            });
+            const svcData = svcQuery?.objects?.[0];
+            if (svcData) {
+                const pub = svcData.bPublished ?? svcData.published ?? svcData.b_publish;
+                const pau = svcData.bPaused ?? svcData.paused ?? svcData.b_pause;
+                serviceStatus = {
+                    published: typeof pub === "boolean" ? pub : null,
+                    paused: typeof pau === "boolean" ? pau : null,
+                };
+            }
+        }
+        catch {
+        }
+    }
+    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");
+    const other = objects.filter(o => !o.role || !VALID_ROLES.has(o.role));
+    if (other.length > 0) {
+        console.warn(`[handleGetProjectDetail] ${other.length} object(s) have invalid or missing role ` +
+            `(expected one of: ${Array.from(VALID_ROLES).join(", ")}). ` +
+            `They are grouped into 'other' for visibility. ` +
+            `Object names: ${other.map(o => o.objectName ?? o.objectAddress).slice(0, 5).join(", ")}${other.length > 5 ? "..." : ""}`);
+    }
+    const objectGroups = {
+        core,
+        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,
+            other_count: other.length,
+            by_type: objects.reduce((acc, o) => {
+                const t = o.objectType ?? "unknown";
+                const prefix = t.includes("::") ? t.split("::")[0].toLowerCase() : t.toLowerCase();
+                acc[prefix] = (acc[prefix] ?? 0) + 1;
+                return acc;
+            }, {}),
+        },
+    };
+    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,
         evaluations: evaluations.map(e => ({
             id: e.id,
             evalType: e.evalType,
@@ -249,9 +526,31 @@ export async function handleGetProjectDetail(v) {
         })),
     };
 }
+const SHORT_TO_FULL_TYPE = {
+    "Service": "0x2::service::Service",
+    "Machine": "0x2::machine::Machine",
+    "Guard": "0x2::guard::Guard",
+    "Permission": "0x2::permission::Permission",
+    "Reward": "0x2::reward::Reward",
+    "Arbitration": "0x2::arbitration::Arbitration",
+    "Progress": "0x2::progress::Progress",
+    "Treasury": "0x2::treasury::Treasury",
+    "Demand": "0x2::demand::Demand",
+    "Repository": "0x2::repository::Repository",
+    "Contact": "0x2::contact::Contact",
+    "Order": "0x2::order::Order",
+    "Allocation": "0x2::allocation::Allocation",
+    "Personal": "0x2::personal::Personal",
+    "Payment": "0x2::payment::Payment",
+    "Proof": "0x2::proof::Proof",
+};
 export async function handleAddObject(v) {
     const projectId = await resolveProjectId(v);
     const objectAddress = await resolveObjectAddress(v);
+    const rawType = v.object_type_add;
+    const objectType = rawType
+        ? (rawType.includes("::") ? rawType : (SHORT_TO_FULL_TYPE[rawType] ?? rawType))
+        : undefined;
     let objectName = v.object_name_add;
     let role = v.object_role;
     if (!objectName) {
@@ -261,7 +560,7 @@ export async function handleAddObject(v) {
         }
     }
     if (!role) {
-        const objType = v.object_type_add ?? "";
+        const objType = objectType ?? "";
         if (objType.includes("service::Service")) {
             role = "core";
         }
@@ -284,7 +583,7 @@ export async function handleAddObject(v) {
     }
     const obj = await localProject.addObject(projectId, {
         objectAddress,
-        objectType: v.object_type_add,
+        objectType,
         objectName,
         role,
         tags: v.object_tags_add,
@@ -335,21 +634,44 @@ export async function handleBuildGraph(v) {
     const project = await localProject.getProject(projectId);
     if (!project)
         throw new Error(`Project not found: ${projectId}`);
+    if (v.async_mode === true) {
+        const taskId = TaskTracker.create("build_graph", projectId);
+        (async () => {
+            try {
+                TaskTracker.update(taskId, 10, "Resolving root address");
+                const result = await buildGraphSync(projectId, project, v);
+                TaskTracker.complete(taskId, result);
+            }
+            catch (err) {
+                TaskTracker.fail(taskId, err.message ?? String(err));
+            }
+        })();
+        return {
+            action: "build_graph",
+            async_mode: true,
+            task_id: taskId,
+            hint: "Graph is building in the background. Call query_task_status with task_id to check progress and retrieve the result.",
+        };
+    }
+    return buildGraphSync(projectId, project, v);
+}
+async function buildGraphSync(projectId, project, v) {
     let rootAddress = project.serviceAddress;
     if (!rootAddress) {
         const objects = await localProject.listObjects(projectId);
         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({
-        maxDepth: v.max_depth ?? 3,
+        maxDepth: v.max_depth ?? v.depth ?? 3,
         enableRegistrar: v.enable_registrar ?? true,
         enablePotential: v.enable_potential ?? false,
         projectId,
-        network: project.network,
+        network: project.network ?? undefined,
     });
     const result = await builder.buildRelationshipGraph(rootAddress);
     const edgesBySource = {};
@@ -357,6 +679,19 @@ export async function handleBuildGraph(v) {
         const src = edge.edgeSource ?? "unknown";
         edgesBySource[src] = (edgesBySource[src] ?? 0) + 1;
     }
+    const topEdges = result.graph.edges
+        .slice()
+        .sort((a, b) => (b.weight ?? 0) - (a.weight ?? 0))
+        .slice(0, 5)
+        .map(e => ({
+        source: e.sourceObject,
+        target: e.targetObject,
+        fieldName: e.fieldName,
+        relationshipType: e.relationshipType,
+        weight: e.weight,
+        verified: e.verified,
+    }));
+    const visualization = topEdges.map(e => `  ${shortLabel(e.source)} --${e.fieldName ?? e.relationshipType ?? ""}--> ${shortLabel(e.target)}`).join("\n");
     return {
         action: "build_graph",
         nodeCount: result.graph.nodes.length,
@@ -364,8 +699,108 @@ export async function handleBuildGraph(v) {
         edgesBySource,
         reputationCount: result.reputation.size,
         builtAt: result.graph.builtAt,
+        topEdges,
+        visualization: visualization || "  (no edges to display)",
+        hint: `Showing top ${topEdges.length} critical edges. Call project_operation with action='get_graph' to list all ${result.graph.edges.length} edges.`,
+        binding_verification: await verifyServiceBindings(project.serviceAddress, project.network),
     };
 }
+async function verifyServiceBindings(serviceAddress, network) {
+    if (!serviceAddress)
+        return null;
+    try {
+        const response = await query_objects({
+            objects: [serviceAddress],
+            network: network,
+        });
+        const svc = response?.objects?.[0];
+        if (!svc)
+            return null;
+        const allocCount = svc.order_allocators?.allocators?.length ?? 0;
+        const arbCount = Array.isArray(svc.arbitrations) ? svc.arbitrations.length : 0;
+        const bindings = {
+            "Service.machine": {
+                expected: "Machine",
+                actual: svc.machine ?? null,
+                verified: !!svc.machine,
+            },
+            "Service.permission": {
+                expected: "Permission",
+                actual: svc.permission ?? null,
+                verified: !!svc.permission,
+            },
+            "Service.buy_guard": {
+                expected: "Guard",
+                actual: svc.buy_guard ?? null,
+                verified: !!svc.buy_guard,
+            },
+            "Service.order_allocators": {
+                expected: "Guard[]",
+                actual: null,
+                count: allocCount,
+                verified: allocCount > 0,
+            },
+            "Service.arbitrations": {
+                expected: "Arbitration[]",
+                actual: null,
+                count: arbCount,
+                verified: arbCount > 0,
+            },
+            "Service.um": {
+                expected: "Contact",
+                actual: svc.um ?? null,
+                verified: !!svc.um,
+            },
+        };
+        const all_verified = Object.values(bindings).every((b) => b.verified);
+        return { service: serviceAddress, bindings, all_verified };
+    }
+    catch {
+        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)";
+    if (!addrOrName.startsWith("0x")) {
+        return addrOrName.length <= 24 ? addrOrName : addrOrName.slice(0, 21) + "...";
+    }
+    return addrOrName.length <= 12 ? addrOrName : addrOrName.slice(0, 10) + "..";
+}
 export async function handleGetGraph(v) {
     const projectId = await resolveProjectId(v);
     const edges = await localProject.getGraph(projectId);
@@ -390,11 +825,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();
@@ -447,6 +897,8 @@ export async function handleEvaluateProject(v) {
         needsLlm: result.needsLlm,
         llmPrompt: result.llmPrompt,
         evaluationId,
+        refreshWarning,
+        graphFallbackWarning,
     };
 }
 export async function handleSaveEvaluation(v) {
@@ -547,6 +999,175 @@ export async function handleDeleteProject(v) {
     await localProject.deleteProject(id);
     return { action: "delete_project", deleted: true };
 }
+export async function handleCloneProjectToNetwork(v) {
+    const sourceProjectId = await resolveProjectId(v);
+    const sourceProject = await localProject.getProject(sourceProjectId);
+    if (!sourceProject) {
+        throw new Error(`Source project not found: ${sourceProjectId}`);
+    }
+    const targetNetwork = requireField(v.target_network, "target_network");
+    if (!["testnet", "mainnet"].includes(targetNetwork)) {
+        throw new Error("target_network must be 'testnet' or 'mainnet'");
+    }
+    const actionName = (v.action === "migrate_network" ? "migrate_network" : "clone_project_to_network");
+    const newPrefix = `${sourceProject.prefix}_${targetNetwork}`;
+    const existing = await localProject.getProjectByPrefix(newPrefix);
+    if (existing) {
+        throw new Error(`Target project prefix '${newPrefix}' already exists (project: '${existing.name}', id: '${existing.id}'). ` +
+            `Use update_project on the existing target or delete it first.`);
+    }
+    const newProject = await localProject.createProject({
+        prefix: newPrefix,
+        name: `${sourceProject.name} (${targetNetwork})`,
+        description: sourceProject.description ?? undefined,
+        industry: sourceProject.industry ?? undefined,
+        perspective: sourceProject.perspective ?? "producer",
+        labels: sourceProject.labels ?? undefined,
+        network: targetNetwork,
+    });
+    const sourceObjects = await localProject.listObjects(sourceProjectId);
+    let clonedCount = 0;
+    for (const obj of sourceObjects) {
+        await localProject.addObject(newProject.id, {
+            objectAddress: `draft:${obj.objectName ?? "unnamed"}`,
+            objectType: obj.objectType !== null ? obj.objectType : undefined,
+            objectName: obj.objectName !== null ? obj.objectName : undefined,
+            role: obj.role ?? "dependency",
+            metadata: {
+                status: "draft",
+                cloned_from: sourceProjectId,
+                cloned_at: Date.now(),
+            },
+        });
+        clonedCount++;
+    }
+    return {
+        action: actionName,
+        new_project_id: newProject.id,
+        new_prefix: newPrefix,
+        target_network: targetNetwork,
+        cloned_objects_count: clonedCount,
+        message: `Project '${sourceProject.prefix}' cloned to ${targetNetwork} as '${newPrefix}'. ${clonedCount} object(s) copied as drafts — object addresses are empty pending on-chain deployment.`,
+        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");
@@ -565,3 +1186,534 @@ export async function handleGetObjectDiff(v) {
         })),
     };
 }
+function normalizeForwards(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map((f) => {
+        const guardObj = f?.guard;
+        const isGuardObj = guardObj && typeof guardObj === "object" && typeof guardObj.guard === "string";
+        const guardAddress = isGuardObj
+            ? guardObj.guard
+            : typeof guardObj === "string" ? guardObj : null;
+        const retainedSubmission = isGuardObj && Array.isArray(guardObj.retained_submission)
+            ? guardObj.retained_submission
+            : null;
+        return {
+            name: typeof f?.name === "string" ? f.name : "",
+            weight: typeof f?.weight === "number" ? f.weight : 0,
+            guard: guardAddress,
+            retained_submission: retainedSubmission,
+            named_operator: typeof f?.namedOperator === "string" ? f.namedOperator : null,
+            permission_index: typeof f?.permissionIndex === "number" ? f.permissionIndex : null,
+        };
+    });
+}
+export async function handleGetMachineGraph(v) {
+    const projectId = await resolveProjectId(v);
+    const machineAddress = 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 machineObj = objects.find(o => o.objectAddress === machineAddress);
+    if (!machineObj) {
+        throw new Error(`Object ${machineAddress} is not part of project '${project.prefix}'. ` +
+            `Add it via add_object first.`);
+    }
+    const network = (project.network ?? "testnet");
+    let machineData = null;
+    try {
+        const queryResult = await query_objects({
+            objects: [machineAddress],
+            network,
+        });
+        machineData = queryResult?.objects?.[0] ?? null;
+    }
+    catch (e) {
+        throw new Error(`Failed to query Machine on ${network}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!machineData) {
+        throw new Error(`Machine ${machineAddress} not found on ${network}. ` +
+            `It may not exist on this network — try switching networks.`);
+    }
+    let machineName = null;
+    const marks = await LocalMark.Instance().list({ address: machineAddress });
+    if (marks.length > 0 && marks[0].name) {
+        machineName = marks[0].name;
+    }
+    const published = typeof machineData.bPublished === "boolean" ? machineData.bPublished : null;
+    const paused = typeof machineData.bPaused === "boolean" ? machineData.bPaused : null;
+    const nodeMap = new Map();
+    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);
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        throw new Error(`Failed to query Machine nodes on ${network}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    for (const nodeObj of rawNodes) {
+        const nodeName = nodeObj.name;
+        if (!nodeName)
+            continue;
+        if (!nodeMap.has(nodeName)) {
+            nodeMap.set(nodeName, { name: nodeName, description: null });
+        }
+        const pairs = Array.isArray(nodeObj.value) ? nodeObj.value : [];
+        for (const pair of pairs) {
+            if (!pair || typeof pair !== "object")
+                continue;
+            const from = typeof pair.prev_node === "string" ? pair.prev_node : "";
+            if (!from)
+                continue;
+            const to = nodeName;
+            const threshold = typeof pair.threshold === "number" ? pair.threshold : 1;
+            const forwards = normalizeForwards(pair.forwards);
+            edgeList.push({ from, to, threshold, forwards });
+        }
+    }
+    for (const edge of edgeList) {
+        if (!nodeMap.has(edge.from)) {
+            nodeMap.set(edge.from, { name: edge.from, description: null });
+        }
+        if (!nodeMap.has(edge.to)) {
+            nodeMap.set(edge.to, { name: edge.to, description: null });
+        }
+    }
+    return {
+        action: "get_machine_graph",
+        machineAddress,
+        machineName,
+        nodes: Array.from(nodeMap.values()),
+        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) {
+    const projectId = await resolveProjectId(v);
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    const missing = [];
+    const warnings = [];
+    const objects = await localProject.listObjects(projectId);
+    if (objects.length === 0) {
+        missing.push({
+            id: "PE-01",
+            description: "Project has no objects (project_objects table is empty).",
+            impact: "Evaluator will return a neutral score with no findings. " +
+                "Call add_object or create_project_from_onchain first.",
+        });
+        return {
+            action: "pre_evaluate_check",
+            ready: false,
+            missing,
+            warnings,
+            summary: "Project is empty — add objects before evaluating.",
+        };
+    }
+    const edges = await localProject.getGraph(projectId);
+    if (edges.length === 0) {
+        warnings.push({
+            id: "PE-02",
+            description: "Project has no graph edges (graph_edges table is empty).",
+            impact: "Evaluator's binding-based checks (machine, permission, " +
+                "buy_guard, order_allocators) will return 0. Call build_graph " +
+                "before evaluate_project to populate edges.",
+        });
+    }
+    const addresses = objects.map(o => o.objectAddress);
+    const cacheEntries = await localProject.getCachedObjects(addresses);
+    const uncached = [];
+    let staleCount = 0;
+    const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    for (const o of objects) {
+        const entry = cacheEntries.get(o.objectAddress);
+        if (!entry) {
+            uncached.push(o.objectAddress);
+        }
+        else {
+            const fetchedAt = entry?.fetchedAt;
+            if (typeof fetchedAt === "number" && (now - fetchedAt) > STALE_THRESHOLD_MS) {
+                staleCount++;
+            }
+        }
+    }
+    if (uncached.length > 0) {
+        warnings.push({
+            id: "PE-03",
+            description: `${uncached.length}/${objects.length} project objects have no cached on-chain data.`,
+            impact: "Evaluator will see empty object data for these objects. " +
+                "Call refresh_objects before evaluate_project to fetch fresh data.",
+        });
+    }
+    if (staleCount > 0) {
+        warnings.push({
+            id: "PE-04",
+            description: `${staleCount}/${objects.length} project objects have cache older than 24 hours.`,
+            impact: "Evaluator results may be based on stale state. " +
+                "Call refresh_objects to fetch fresh data.",
+        });
+    }
+    const knownAddresses = new Set(objects.map(o => o.objectAddress));
+    const knownNames = new Set(objects.map(o => o.objectName).filter(Boolean));
+    const danglingEdges = edges.filter((e) => !knownAddresses.has(e.sourceObject) && !knownNames.has(e.sourceObject)
+        && !knownAddresses.has(e.targetObject) && !knownNames.has(e.targetObject));
+    if (danglingEdges.length > 0) {
+        warnings.push({
+            id: "PE-05",
+            description: `${danglingEdges.length} graph edges reference objects not in project_objects.`,
+            impact: "Evaluator's binding index may include stale/dangling entries. " +
+                "Call build_graph again to refresh edges, or remove orphan objects.",
+        });
+    }
+    if (project.perspective === "producer") {
+        const hasService = objects.some(o => isObjectOfType(o.objectType, "service"));
+        if (!hasService) {
+            missing.push({
+                id: "PE-06",
+                description: "Producer project has no Service-type object.",
+                impact: "Evaluator's service-centric checks (publish state, " +
+                    "machine binding, order_allocators, etc.) will all return 0. " +
+                    "Add a Service object or import one via create_project_from_onchain.",
+            });
+        }
+    }
+    const draftCount = objects.filter((o) => {
+        const meta = (o.metadata ?? {});
+        return meta.status === "draft" || o.objectAddress.startsWith("draft:");
+    }).length;
+    if (draftCount === objects.length && objects.length > 0) {
+        warnings.push({
+            id: "PE-07",
+            description: `All ${objects.length} objects are draft (not yet on-chain).`,
+            impact: "Evaluator will assess the blueprint as if it were on-chain. " +
+                "Real on-chain state may differ once deployed.",
+        });
+    }
+    const ready = missing.length === 0;
+    const summary = ready
+        ? (warnings.length === 0
+            ? `Ready to evaluate. ${objects.length} objects, ${edges.length} edges.`
+            : `Ready to evaluate with ${warnings.length} warning(s). ${objects.length} objects, ${edges.length} edges.`)
+        : `Not ready: ${missing.length} blocking issue(s) found.`;
+    return {
+        action: "pre_evaluate_check",
+        ready,
+        missing,
+        warnings,
+        summary,
+        counts: {
+            objects: objects.length,
+            edges: edges.length,
+            uncached: uncached.length,
+            stale: staleCount,
+            dangling_edges: danglingEdges.length,
+            drafts: draftCount,
+        },
+    };
+}
+export async function handleVerifyDeployment(v) {
+    const projectId = await resolveProjectId(v);
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    const objects = await localProject.listObjects(projectId);
+    if (objects.length === 0) {
+        return {
+            action: "verify_deployment",
+            verifiedCount: 0,
+            matched: 0,
+            mismatched: 0,
+            missing: 0,
+            unreachable: 0,
+            results: [],
+            summary: "Project has no objects to verify.",
+        };
+    }
+    const network = (project.network ?? "testnet");
+    const deployedObjects = objects.filter((o) => !o.objectAddress.startsWith("draft:") && o.objectAddress.startsWith("0x"));
+    if (deployedObjects.length === 0) {
+        return {
+            action: "verify_deployment",
+            verifiedCount: 0,
+            matched: 0,
+            mismatched: 0,
+            missing: 0,
+            unreachable: 0,
+            results: [],
+            summary: `All ${objects.length} objects are draft or non-address — nothing to verify on-chain.`,
+        };
+    }
+    const batchSize = Math.min(deployedObjects.length, 50);
+    const addressesToQuery = deployedObjects.slice(0, batchSize).map(o => o.objectAddress);
+    let chainResult;
+    try {
+        chainResult = await query_objects({
+            objects: addressesToQuery,
+            network,
+        });
+    }
+    catch (e) {
+        return {
+            action: "verify_deployment",
+            verifiedCount: 0,
+            matched: 0,
+            mismatched: 0,
+            missing: 0,
+            unreachable: deployedObjects.length,
+            results: deployedObjects.map(o => ({
+                objectAddress: o.objectAddress,
+                objectName: o.objectName,
+                objectType: o.objectType,
+                status: "unreachable",
+                error: e instanceof Error ? e.message : String(e),
+            })),
+            summary: `Failed to query on-chain state: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+    const chainObjects = chainResult?.objects ?? [];
+    const chainByAddress = new Map();
+    for (const co of chainObjects) {
+        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 = [];
+    let matched = 0, mismatched = 0, missing = 0;
+    for (const obj of deployedObjects.slice(0, batchSize)) {
+        const chainObj = chainByAddress.get(obj.objectAddress);
+        if (!chainObj) {
+            missing++;
+            results.push({
+                objectAddress: obj.objectAddress,
+                objectName: obj.objectName,
+                objectType: obj.objectType,
+                status: "missing",
+            });
+            continue;
+        }
+        const chainData = chainObj;
+        const sqliteData = (await localProject.getCachedObjects([obj.objectAddress])).get(obj.objectAddress);
+        const sqliteFields = sqliteData?.data ?? {};
+        const differences = [];
+        let bindings;
+        if (isObjectOfType(obj.objectType, "service")) {
+            const fieldsToCompare = ["machine", "permission", "buy_guard", "arbitrations", "rewards", "repositories"];
+            for (const f of fieldsToCompare) {
+                const sqliteVal = sqliteFields[f];
+                const chainVal = chainData[f];
+                const norm = (v) => (v === null || v === undefined || v === "") ? null : v;
+                if (JSON.stringify(norm(sqliteVal)) !== JSON.stringify(norm(chainVal))) {
+                    differences.push({ field: f, sqlite: sqliteVal, onchain: chainVal });
+                }
+            }
+            bindings = {
+                machine: !!chainData.machine,
+                permission: !!chainData.permission,
+                buy_guard: !!chainData.buy_guard,
+                order_allocators: !!chainData.order_allocators,
+            };
+            if (sqliteFields.bPublished !== undefined && chainData.bPublished !== undefined
+                && sqliteFields.bPublished !== chainData.bPublished) {
+                differences.push({
+                    field: "bPublished",
+                    sqlite: sqliteFields.bPublished,
+                    onchain: chainData.bPublished,
+                });
+            }
+        }
+        else if (isObjectOfType(obj.objectType, "machine")) {
+            if (sqliteFields.bPublished !== undefined && chainData.bPublished !== undefined
+                && sqliteFields.bPublished !== chainData.bPublished) {
+                differences.push({
+                    field: "bPublished",
+                    sqlite: sqliteFields.bPublished,
+                    onchain: chainData.bPublished,
+                });
+            }
+            const sqliteNodeCount = sqliteFields.node_count;
+            const chainNodeCount = chainData.node_count;
+            if (sqliteNodeCount !== undefined && chainNodeCount !== undefined
+                && sqliteNodeCount !== chainNodeCount) {
+                differences.push({
+                    field: "node_count",
+                    sqlite: sqliteNodeCount,
+                    onchain: chainNodeCount,
+                });
+            }
+        }
+        if (differences.length > 0) {
+            mismatched++;
+            results.push({
+                objectAddress: obj.objectAddress,
+                objectName: obj.objectName,
+                objectType: obj.objectType,
+                status: "mismatched",
+                differences,
+                bindings,
+            });
+        }
+        else {
+            matched++;
+            results.push({
+                objectAddress: obj.objectAddress,
+                objectName: obj.objectName,
+                objectType: obj.objectType,
+                status: "matched",
+                bindings,
+            });
+        }
+    }
+    const summary = matched === deployedObjects.length
+        ? `All ${matched} deployed objects verified.`
+        : `${matched} matched, ${mismatched} mismatched, ${missing} missing.`;
+    return {
+        action: "verify_deployment",
+        verifiedCount: results.length,
+        matched,
+        mismatched,
+        missing,
+        unreachable: 0,
+        results,
+        summary,
+    };
+}